Archive for the ‘csharp’ Category.

Understanding async and await, Task.WaitAll, Task.Run, and parallelism

Ok. You are probably new to async and await or maybe you aren’t new but you’ve never deep dived into it. You may not understand some simple truths:

  1. aync/await does NOT give you parallelism for free.
  2. Tasks are not necessary parallel. They can be if you code them to be.
  3. The recommendation “You should always use await” is not really true when you want parallelism, but is still sort of true.
  4. Task.WhenAll is both parallel and async.
  5. Task.WaitAll only parallel.

Here is a sample project that will help you learn.

There is more to learn in the comments.
There is more to learn by running this.

Note: I used Visual Studio 2017 and compiled with .Net 7.1, which required that I go to the project properties | Build | Advanced | Language Version and set the language to C# 7.1 or C# latest minor version.

using System;
using System.Diagnostics;
using System.Threading.Tasks;

namespace MultipleAwaitsExample
{
    class Program
    {
        static async Task Main(string[] args)
        {
            Console.WriteLine("Running with await");
            await RunTasksAwait();
            Console.WriteLine("Running with Task.WaitAll()");
            await RunTasksWaitAll();
            Console.WriteLine("Running with Task.WhenAll()");
            await RunTasksWhenAll();
            Console.WriteLine("Running with Task.Run()");
            await RunTasksWithTaskRun();
            Console.WriteLine("Running with Parallel");
            RunTasksWithParallel();
        }

        /// <summary>
        /// Pros: It works
        /// Cons: The tasks are NOT run in parallel.
        ///       Code after the await is not run while the await is awaited
        ///       **If you want parallelism, this isn't even an option.**
        ///       Slowest. Because of no parallelism.
        /// </summary>
        public static async Task RunTasksAwait()
        {
            var group = "await";
            Stopwatch watcher = new Stopwatch();
            watcher.Start();
            await MyTaskAsync(1, 500, group);
            await MyTaskAsync(2, 300, group);
            await MyTaskAsync(3, 100, group);
            Console.WriteLine("Code immediately after tasks.");
            watcher.Stop();
            Console.WriteLine($"{group} runtime: {watcher.ElapsedMilliseconds}");
        }

        /// <summary>
        /// WaitAll behaves quite differently from WhenAll
        /// Pros: It works
        ///       The tasks run in parallel
        /// Cons: It isn't clear whether the code is parallel here, but it is.
        ///       It isn't clear whether the code  is async here, but it is NOT.
        ///       There is a Visual Studio usage warning. You can remove async to get rid of it because it isn't an Async method.
        ///       The return value is wrapped the Result property of the task
        ///       Breaks Aync end-to-end
        ///       Note: I can't foresee usecase where WaitAll would be preferred over WhenAll.
        /// </summary>
        public static async Task RunTasksWaitAll()
        {
            var group = "WaitAll";
            Stopwatch watcher = new Stopwatch();
            watcher.Start();
            var task1 = MyTaskAsync(1, 500, group);
            var task2 = MyTaskAsync(2, 300, group);
            var task3 = MyTaskAsync(3, 100, group);
            Console.WriteLine("Code immediately after tasks.");
            Task.WaitAll(task1, task2, task3);
            watcher.Stop();
            Console.WriteLine($"{group} runtime: {watcher.ElapsedMilliseconds}");
        }

        /// <summary>
        /// WhenAll gives you the best of all worlds. The code is both parallel and async.
        /// Pros: It works
        ///       The tasks run in parallel
        ///       Code after the tasks run while the task is running
        ///       Doesn't break end-to-end async
        /// Cons: It isn't clear you are doing parallelism here, but you are.
        ///       There is a Visual Studio usage warning
        ///       The return value is wrapped the Result property of the task
        /// </summary>
        public static async Task RunTasksWhenAll()
        {
            var group = "WaitAll";
            Stopwatch watcher = new Stopwatch();
            watcher.Start();
            var task1 = MyTaskAsync(1, 500, group);  // You can't use await if you want parallelism
            var task2 = MyTaskAsync(2, 300, group);
            var task3 = MyTaskAsync(3, 100, group);
            Console.WriteLine("Code immediately after tasks.");
            await Task.WhenAll(task1, task2, task3); // But now you are calling await, so you are sort of still awaiting
            watcher.Stop();
            Console.WriteLine($"{group} runtime: {watcher.ElapsedMilliseconds}");
        }

        /// <summary>
        /// Pros: It works
        ///       The tasks run in parrallel
        ///       Code can run immediately after the tasks but before the tasks complete
        ///       Allows for running non-async code asynchonously
        /// Cons: It isn't clear whether the code is doing parallelism here. It isn't.
        ///       The lambda syntax affects readability
        ///       Breaks Aync end-to-end
        /// </summary>
        public static async Task RunTasksWithTaskRun()
        {
            var group = "Task.Run()";
            Stopwatch watcher = new Stopwatch();
            watcher.Start();
            await Task.Run(() => MyTask(1, 500, group));
            await Task.Run(() => MyTask(2, 300, group));
            await Task.Run(() => MyTask(3, 100, group));
            Console.WriteLine("Code immediately after tasks.");
            watcher.Stop();
            Console.WriteLine($"{group} runtime: {watcher.ElapsedMilliseconds}");
        }

        /// <summary>
        /// Pros: It works
        ///       It is clear in the code you want to run these tasks in parallel.
        ///       Code can run immediately after the tasks but before the tasks complete
        ///       Fastest
        /// Cons: There is no async or await.
        ///       Breaks Aync end-to-end. You can workaround this by wrapping Parallel.Invoke in a Task.Run method. See commented code.
        /// </summary>
        public /* async */ static void RunTasksWithParallel()
        {
            var group = "Parallel";
            Stopwatch watcher = new Stopwatch();
            watcher.Start();
            //await Task.Run(() => 
            Parallel.Invoke(
                () => MyTask(1, 500, group),
                () => MyTask(2, 300, group),
                () => MyTask(3, 100, group),
                () => Console.WriteLine("Code immediately after tasks.")
            );
            //);
            
            watcher.Stop();
            Console.WriteLine($"{group} runtime: {watcher.ElapsedMilliseconds}");
        }

        public static async Task MyTaskAsync(int i, int milliseconds, string group)
        {
            await Task.Delay(milliseconds);
            Console.WriteLine($"{group}: {i}");
        }

        public static void MyTask(int i, int milliseconds, string group)
        {
            var task = Task.Delay(milliseconds);
            task.Wait();
            Console.WriteLine($"{group}: {i}");
        }
    }
}

And here is the same example but this time with some return values.

using System;
using System.Diagnostics;
using System.Threading.Tasks;

namespace MultipleAwaitsExample
{
    class Program1
    {
        static async Task Main(string[] args)
        {
            Console.WriteLine("Running with await");
            await RunTasksAwait();
            Console.WriteLine("Running with Task.WaitAll()");
            await RunTasksWaitAll();
            Console.WriteLine("Running with Task.WhenAll()");
            await RunTasksWhenAll();
            Console.WriteLine("Running with Task.Run()");
            await RunTasksWithTaskRun();
            Console.WriteLine("Running with Parallel");
            RunTasksWithParallel();
        }

        /// <summary>
        /// Pros: It works
        /// Cons: The tasks are NOT run in parallel.
        ///       Code after the await is not run while the await is awaited
        ///       **If you want parallelism, this isn't even an option.**
        ///       Slowest. Because of no parallelism.
        /// </summary>
        public static async Task RunTasksAwait()
        {
            var group = "await";
            Stopwatch watcher = new Stopwatch();
            watcher.Start();
            // You just asign the return variables as normal.
            int result1 = await MyTaskAsync(1, 500, group);
            int result2 = await MyTaskAsync(2, 300, group);
            int result3 = await MyTaskAsync(3, 100, group);
            Console.WriteLine("Code immediately after tasks.");
            watcher.Stop();
            // You now have access to the return objects directly.
            Console.WriteLine($"{group} runtime: {watcher.ElapsedMilliseconds}");
        }

        /// <summary>
        /// WaitAll behaves quite differently from WhenAll
        /// Pros: It works
        ///       The tasks run in parallel
        /// Cons: It isn't clear whether the code is parallel here, but it is.
        ///       It isn't clear whether the code  is async here, but it is NOT.
        ///       There is a Visual Studio usage warning. You can remove async to get rid of it because it isn't an Async method.
        ///       The return value is wrapped the Result property of the task
        ///       Breaks Aync end-to-end
        ///       Note: I can't foresee usecase where WaitAll would be preferred over WhenAll.
        /// </summary>
        public static async Task RunTasksWaitAll()
        {
            var group = "WaitAll";
            Stopwatch watcher = new Stopwatch();
            watcher.Start();
            var task1 = MyTaskAsync(1, 500, group);
            var task2 = MyTaskAsync(2, 300, group);
            var task3 = MyTaskAsync(3, 100, group);
            Console.WriteLine("Code immediately after tasks.");
            Task.WaitAll(task1, task2, task3);
            watcher.Stop();
            // You now have access to the return object using the Result property.
            int result1 = task1.Result;
            int result2 = task2.Result;
            int result3 = task3.Result;
            Console.WriteLine($"{group} runtime: {watcher.ElapsedMilliseconds}");
        }

        /// <summary>
        /// WhenAll gives you the best of all worlds. The code is both parallel and async.
        /// Pros: It works
        ///       The tasks run in parallel
        ///       Code after the tasks run while the task is running
        ///       Doesn't break end-to-end async
        /// Cons: It isn't clear you are doing parallelism here, but you are.
        ///       There is a Visual Studio usage warning
        ///       The return value is wrapped the Result property of the task
        /// </summary>
        public static async Task RunTasksWhenAll()
        {
            var group = "WaitAll";
            Stopwatch watcher = new Stopwatch();
            watcher.Start();
            var task1 = MyTaskAsync(1, 500, group);  // You can't use await if you want parallelism
            var task2 = MyTaskAsync(2, 300, group);
            var task3 = MyTaskAsync(3, 100, group);
            Console.WriteLine("Code immediately after tasks.");
            await Task.WhenAll(task1, task2, task3); // But now you are calling await, so you are sort of still awaiting
            watcher.Stop();
            Console.WriteLine($"{group} runtime: {watcher.ElapsedMilliseconds}");
        }

        /// <summary>
        /// Pros: It works
        ///       The tasks run in parrallel
        ///       Code can run immediately after the tasks but before the tasks complete
        ///       Allows for running non-async code asynchonously
        /// Cons: It isn't clear whether the code is doing parallelism here. It isn't.
        ///       The lambda syntax affects readability
        ///       Breaks Aync end-to-end
        /// </summary>
        public static async Task RunTasksWithTaskRun()
        {
            var group = "Task.Run()";
            Stopwatch watcher = new Stopwatch();
            watcher.Start();
            int result1 = await Task.Run(() => MyTask(1, 500, group));
            int result2 = await Task.Run(() => MyTask(2, 300, group));
            int result3 = await Task.Run(() => MyTask(3, 100, group));
            Console.WriteLine("Code immediately after tasks.");
            watcher.Stop();
            // You now have access to the return objects directly.
            Console.WriteLine($"{group} runtime: {watcher.ElapsedMilliseconds}");
        }

        /// <summary>
        /// Pros: It works
        ///       It is clear in the code you want to run these tasks in parallel.
        ///       Code can run immediately after the tasks but before the tasks complete
        ///       Fastest
        /// Cons: There is no async or await.
        ///       Breaks Aync end-to-end. You can workaround this by wrapping Parallel.Invoke in a Task.Run method. See commented code.
        /// </summary>
        public /* async */ static void RunTasksWithParallel()
        {
            var group = "Parallel";
            Stopwatch watcher = new Stopwatch();
            watcher.Start();
            // You have to declare your return objects before hand.
            //await Task.Run(() => 
            int result1, result2, result3;
            Parallel.Invoke(
                () => result1 = MyTask(1, 500, group),
                () => result2 = MyTask(2, 300, group),
                () => result3 = MyTask(3, 100, group),
                () => Console.WriteLine("Code immediately after tasks.")
            );
            //);
            // You now have access to the return objects directly.
            watcher.Stop();
            Console.WriteLine($"{group} runtime: {watcher.ElapsedMilliseconds}");
        }

        public static async Task<int> MyTaskAsync(int i, int milliseconds, string group)
        {
            await Task.Delay(milliseconds);
            Console.WriteLine($"{group}: {i}");
            return i;
        }

        public static int MyTask(int i, int milliseconds, string group)
        {
            var task = Task.Delay(milliseconds);
            task.Wait();
            Console.WriteLine($"{group}: {i}");
            return i;
        }
    }
}

Code faster and with higher quality using code generation

Code generation is the idea of having a tool write code written for you. If you use a modern IDE, such Visual Studio, you likely use a type of code generation, even if you think you don’t.

Anytime code is written for you, it is code generation. You use code generation whenever you do the following:

  1. Create a new solution or project – Each project is a template with a base set of code ready for you to use.
  2. Add a new class, interface, or another item to a project – When adding a new class to a project, the class comes with a pre-created class object. If you add a new class called Person, the following class file would be created and added to the project:
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace LANDesk.Licensing.WebServices.File.Tests
    {
        class Person
        {
        }
    }
    

    The using statements are lines of code. The namespace and class definitions and the brackets are lines of code.  You get 11 lines of code not including the whitespace lines. This code was created for you because you didn’t have to write it. That doesn’t mean it is 100% useful. If you don’t use threading, the last using statement can be removed.

    Similarly, other items that are added have a base set of code.

  3. Use code snippets – Code Snippets are quite powerful. With a few characters and then the tab key twice, you can create a lot of code. There are many built-in code snippets. If you are using them, you should be.
  4. Other Visual Studio features – Visual Studio has some specific use cases where it provides code generation. For example, if you highlight a class name and choose Extract Interface, Visual Studio will generate and interface from the
  5. Plugins and 3rd party tools – Many plugins can generate code for you. For example, Resharper can do numerous code generation features, such as properly overriding the Equals method. ORMs, such as Entity Framework, have code generation tools. Entity Framework can generate most the Entities (class files that represent objects stored in database tables)  for you.

You can enhance the code generation tools

Most of these features are available as platforms for you to build upon. Enhancing these can be a simple as copying an existing item or as complex as developing your own product.

In Visual Studio, you can do any of the following: (listed in order of ease of use)

  1. Create your own snippets.
  2. Create your own class/item templates
  3. Download or purchase additional code generation plugins
  4. Create your own Project/Solution templates
  5. Create your own Visual Studio plugins/3rd party tools

If you are repeatedly writing the same code over an over again, you probably would benefit from creating a code generation solution.

Faster and higher Quality

When a human writes something, there is room for human error. If a person writes the same thing over and over, there is a tendency to minimize and cut corners. Also, there are many standard pieces of code that have already gone through significant use and bug fixes resulting in a stable and scalable piece of code. For example, overriding Equals in a class isn’t always straight forward. If you do it yourself, you might be left wondering if you have properly overridden Equals of if your implementation has well-known bugs? Do you leave those bugs in or research and fix them? If you research and fix them, how long will it take you each time you override Equals to make sure you accounted for all well-known bugs? However, if you use a generator with a standard, tested, and bug-free piece of code, your code will be higher quality and it will be created almost instantly. See, faster and higher quality.

I am hoping to have time to create a series of posts on this topic, starting with Snippets. But to get you started, check out my Visual Studio snippets for C# on GitHub.

https://github.com/rhyous/VisualCSharpSnippets

 

SQL Query to Entity Framework Cheat Sheet

The following are examples of SQL queries and how to execute them with Entity Framework

SELECT * with Entity Framework

SELECT * FROM Contacts
var mydbContext.Contacts.ToList();

SELECT Id with Entity Framework

This is really for how to select any single column.

SELECT Id FROM Contacts
List<int> idList = dbContext.Contacts.Select( c => c.Id ).ToList(); // Assuming Id is of type int

SELECT only one row with Entity Framework

This is really for how to select any single row from a table.

SELECT * FROM Contacts where Id = 10
var id = 10;
var contact = dbContext.Contacts.SingleOrDefault( c => c.Id = id );

SELECT only one result with Entity Framework

This is really for how to select any single value from a single row in a table.

SELECT UserId FROM Contacts where Id = 10
var id = 10;
int userId = dbContext.Contacts.Where( c => c.Id = id ).Select( c => c.UserId ).SingleOrDefault();

SELECT first result with Entity Framework

This is really for how to select the first value from a list of returned rows from a table.

SELECT TOP 1 * FROM Contacts
var id = 10;
int userId = dbContext.Contacts.FirstOrDefault();

INSERT INTO with Entity Framework

INSERT INTO dbo.LD_User (Name, Type, Active, CreateDate, CreatedBy)
VALUES ('user1', 1, 1, GetDate(), 101)
var user = new User { Name = "user1", Type = UserType.Contact, true, DateTime.Now, User.System };
dbContext.Users.Add(user);
dbContext.SaveChanges();

Note: UserType.Contact and User.System are enums in the above example.

INSERT INTO … SELECT with Entity Framework

Imagine you have these three tables. Product, ProductGroup, ProductGroupMembership. You want to make Products a member of a group by inserting into the ProductGroupMembership table.

INSERT INTO ProductGroupMembership (ProductId, GroupId, CreateDate, CreatedBy)
SELECT Id, @GroupId, GetDate(), @CreatedBy FROM Product
WHERE Id IN (1, 2, 3, 4, 5) -- there could be hundreds or thousands of numbers in the IN statement
EPIC FAIL!!! Can't be done without raw sql and opening up to sql injection attacks.

However, you can create a stored procedure that takes and user-defined table called ArrayOfInt. Then add EntityFrameworkExtras.EF6, which is available as a NuGet package, to call the storedprocedure and pass it an array.

WHERE with many AND/ORs with Entity Framework

Imagine you have these three tables. Product, ProductGroup, ProductGroupMembership. You want to make Products a member of a group by inserting into the ProductGroupMembership table.

You have a list of software Products provided to you. However, the input only includes Product.Name and Product.Version. You now need to check if the products exist and get the id.

SELECT Id FROM Product
WHERE (Name = 'Product 1' AND Version = '10.0')
WHERE (Name = 'Product 2' AND Version = '10.0')
WHERE (Name = 'Product 3' AND Version = '10.1')
WHERE (Name = 'Product 4' AND Version = '10.0')
WHERE (Name = 'Product 5' AND Version = '1.0')
EPIC FAIL!!! Can't be done without raw sql

However, you can add LinqKit’s PredicateBuilder to do this. PredicateBuilder works on top of Entity Framework and is available as a NuGet package. See how I used it here: Entity Framework and many WHERE clauses

Entity Framework and many WHERE clauses

So today, I needed to get Entity Framework to return me a list of Products from the database based on a list of Product.Name and Product.Version values (not Ids). If it were Product.Id, it would have been simple as I could have used an IN statement, but it wasn’t.

The query might get many (maybe hundreds at a time) products based on the list. Here is the query I imagined.

So when doing a query like this, since there could be hundreds, I have a couple of options.

  1. Query the database once for each product.
    SELECT * FROM dbo.Product
    WHERE (Name = 'Product 1' AND Version = '10.0')
    

    Repeat this same query once for each Product.

  2. Query the database one time with an or clause for each Product.Name and Product.Version.
    SELECT * FROM dbo.Product
    WHERE (Name = 'Product 1' AND Version = '10.0')
       OR (Name = 'Product 2' AND Version = '10.0')
       OR (Name = 'Product 3' AND Version = '10.0')
       OR (Name = 'Product 4' AND Version = '1.0')
       -- There could be hundreds
    
  3. Query the database once and get all products and use code to find the ones I wanted.
    SELECT * FROM dbo.Product
    

Option 1
I didn’t like this option because I could end up doing hundreds of single queries. That doesn’t sound like a good idea. What would the performance impact would be when doing hundreds of single queries? The overhead of traversing over the network to the database would prevent this option from scaling.

Option 2
This is the option I imagined in my head. My gut said to use this option.

Option 3
This would work. We only have about two thousand products today and querying them all would, right now, not be bad at all. However, we just bought a company and will be adding more products. We plan to buy more companies. Also, we have two companies that we have already bought and have yet to add those products in. When would the number of Product rows in the database make the SELECT * and invalid option? Doing this would work now, but it leave a time bomb for some future developer encounter and have to fix.

Winner: Option 2

Problem
Entity Framework doesn’t really have an easy way to create the Option 2 query.

So, how do I create this query with many where statements?

Here are the two options I’ve found:

Inline SQL Query with Entity Framework

        private static List<Product> GetProductsByNameAndVersion(ActivationDbContext dbContext, IEnumerable<ProductRequest> products)
        {
            if (!products.Any())
            {
                return new List<Product>();
            }
            var query = "Select * FROM Product WHERE ";
            var or = "";
            var template = "(Name = '{0}' AND Version = '{1}')";
            foreach (var prod in products)
            {
                query += or;
                query += string.Format(template, prod.Name, prod.Version);
                or = " OR ";
            }
            var dbProducts = dbContext.Products.SqlQuery(query).ToList();
            return dbProducts.ToList();
        }

This option means I have to create magic strings and make sure that I handle the strings correctly. It has bugs already. Such as what if a product only has a name and not a version (version could be null or empty, who knows) or vice-versa? How would this affect my query string?

PredicateBuilder

Predicate Builder from the LinqKit library which is available as a NuGet package.

        private static List<Product> GetProductsByNameAndVersionPredicate(ActivationDbContext dbContext, IEnumerable<ProductRequest> products)
        {
            if (!products.Any())
            {
                return new List<Product>();
            }

            var predicate = PredicateBuilder.False<Product>();

            foreach (var prod in products)
            {
                var inner = PredicateBuilder.True<Product>();
                inner = inner.And(p => p.Name== prod.Name);
                inner = inner.And(p => p.Version == prod.Version);
                predicate = predicate.Or(inner);
            }
            var dbProducts = dbContext.Products.AsExpandable().Where(predicate).ToList();
            return dbProducts;            
        }

PredicateBuilder isn’t very intuitive. For starters, what is the different between these methods:

  • PredicateBuilder.True() – from what I understand this would be more appropriate and understandable as PredicateBuilder.And()
  • PredicateBuilder.False() – from what I understand this would be more appropriate and understandable as PredicateBuilder.Or()

Also, you have to remember to call AsExpandable() on the first call to a table in order to use it.

Conclusion

I am going to go with PredicateBuilder for now. It feels cleaner than rolling my own string query. But both solutions ultimately worked. That means that Entity Framework ultimately provided me a solution without an extra library. However, LinqKit saved me from magic strings. My only question is this: Why isn’t a predicate builder built into Entity Framework?

10+ Reasons why Java needs C#’s property syntax

Written in response, to all the Java developers who claim that Java doesn’t need C#’s property syntax.

The truth is most C# developers can’t quantify all the benefits to C# properties because there are so many. Most arguments I have seen from C# developers have been weak at best. These arguments fail to provide the Java development team a good enough reason to implement C#-like properties.

A proper analogy would be the Pyramids. You can’t point to one brick and say, “That brick makes the pyramid,” because every brick is small (relative the size of the who pyramid), but together, each brick is important to making the pyramid and altogether, they are one of the seven wonders of the world. Similarly, C# Properties provide many little features that together improve the language far more significantly than most can’t quantify.

Properties are quite awesome and provide some great features that Java cannot do now.

1. Easy refactoring when moving from a simple member variable to a property.

Properties using the same syntax as a member variable enable more than one feature, but we are going to talk about only this feature here to start.

public class MyObj
{
   public int Id;
   public String Name;
}

The program starts off with this because for years simplicity is all that is needed.

Note: A getter and a setter provide little to no benefit for a model object. If you aren’t encapsulating code on get and set, using a getter and setter gets in the way. Also, a using a getter and a setter is only a convention anyway, and not forced by the language. As such, getters and setters can’t be relied upon.

A year later, you find that you need to add some feature on name set. You change your class. In Java, you have to create getters and setters.

public class MyObj
{
   public int id;
   private String _Name;
   public String getName(){return _Name;}
   public void setName(string value) {
      _Name = value; 
      // More work here
   }
}

Now every single line of code that calls MyObj.Name is broken. However, with properties, this wouldn’t the case.

public class MyObj
{
   public int id;
   private String Name {
      get { return _Name; } 
      set {
         _Name = value;
         // more work here
      }
   }
}

None of my existing code broke using the property example. This sounds trivial but what if you are an API that hundreds of other tools consume and use. Now this a breaking change that has a massive impact on a business. This feature is huge.

Can Java change a class today from a member variable to a method without breaking an API? No, it cannot. Does this happen often? No, but when it does, it is a breaking change without properties, while with properties, it works without a second thought.

Important: This feature is also why so many hacks that suggest that Java adds a language construct that creates getProperty and setProperty methods are still broken. I’ve seen recommendations such as this where the suggestion is for the compiler and IntelliSense to just convert these to getProperty and setProperty:

public class MyObj
{
   @get @set String Name;
   public MyObj()
   {
      setName("Rhyous");// Default value
   }
}

That syntax doesn’t solve the problem. In order to solve this problem, the syntax still has to be this:

public class MyObj
{
   @get @set String Name;
   public MyObj()
   {
      Name = "Rhyous";// Default value
   }
}

However, even with this, the suggested syntax is not the right suggestion. While the above syntax works for auto properties, how would code be added to the get or set method? The above syntactical sugar, while better than what java has now, is lacking compared to C#’s implementation and would result in fewer features.

2. Replacing an object that uses member variables with an interface

This is similar to #1. You have an object and need to create a layer of abstraction and use an interface for that object. But the object uses only member variables? How can you create an interface for the following syntax in Java?

MyObj.Name

You can’t. So to add a layer of abstraction, you now have to first refactor code. Again, as mentioned in #1, moving from MyObj.Name to MyObj.getName() and MyObj.setName() is a breaking change, especially in a API. It can have a massive impact.

Now, before you argue that you would never need to add a layer of abstraction for a simple object, let me remind you that all objects are not simple. I agree, on a simple model object, abstraction wouldn’t be necessary. However, the problem is certainly with a method on an object that also has public members. But you need the whole object, not just the method. And interface with only methods won’t be enough.

MyObj.Name
MyObj.CallServer();

Well, we can’t use the CallServer() method as is in a Unit Test. We need to use and interface and dependency injection and good language architecture. We have to refactor some. But we with properties we don’t need to make a breaking change. Without properties, we do. We have to change from MyObj.Name to MyObj.getName().

3. Properties are different than member variables and methods and reflection reflects that.

C# has reflection. You can loop through all members, properties, and methods separately. In Java, you have something similar. But no way to get properties separate from other methods.

When you only want to loop through getters and setters in Java, how do you do that? Unless every getter and setter is perfectly named getProperty setProperty and none of the methods that are not getters or setters have the format of getSomething setComething, you can’t.

Can you loop through only properties today in Java? Maybe. Java cannot guarantee this ability.

4. Sharing objects between Java and C#.

This feature goes beyond properties, but the lack of a Property syntax is the biggest barrier.

In order to do this today, the object has to be written in Java and C#. C# developers have to live with the more verbose getProperty() setPropert() syntax. For example: MyObj.Id++ is nice and clean but the equivalent in java is MyObj.setId(MyOjb.getId() + 1);

Some tools, such as Hibernate/NHibernate, would benefit greatly from this feature.

5. Properties let you write with cleaner and shorter syntax.

You save programming time. You save lines of code. Look below, as three lines become one.

private String _Name;
public String getName() { return _Name; };
private void setName(String name) { _Name = name; }

vs

public string Name { get; set; }

Java is not just a little more typing, it is a lot more typing. While you can argue that snippets or IDE code generator tools take care of this, I’d argue that C# has snippets and code generators, too. I can type prop tab in Visual Studio and have property pretty quickly so at best, snippets help Java almost catch up in development speed.

Also, let’s not forget that this is one single feature. I could write a whole article about all the ways that C#’s property syntax is cleaner and shorter than Java’s syntax.

How about adding one to an int?

MyObj.Id++;

vs in Java

MyObj.setId(MyObj.getId() + 1);

Again, a shorter and simpler syntax probably is a few dozen features as it will be used in so many different ways for so many different language benefits, not just one.

6. Most the property data is in one place.

This provides multiple features:

  • Easier to rename
  • Easier to copy and paste
  • Easier to identify as a property
public string Name { get; set; }
[csharp]

And in C#, a new syntax was added to make it so you no longer need to break this out to a backing field to set a default value.

[csharp]
public string Name { get; set; } = "Rhyous";

In java, there is no guarantee that properties are all together. I have seen code like this where the properties are not together in java.

public class MyObj 
{
  // Members
  private Integer _Id;
  private String _Name;

  // Getters
  public Integer getId() { return _Id; };
  public String getName() { return _Name; };

  // Setters
  public void setId(int id) { _Id = id; };
  public void setName(String name) { _Name = name; }
}

While this is fine, it makes renaming have to occur in 7 places in three lines that are separated and could be anywhere in the class file. (Count all the times Name or Id is used and it is 7 times.) In C#, it is once with an auto property and only four times with a property with a backing field. Of course, C# has the same problem once you use a backing field. The backing field isn’t always together with the property, that is only two items that can be separate, not three. In Java, keeping it together would have to be by convention. I use this convention in C# to keep backing fields together.

public string Name 
{ 
  get {return _Name; } 
  set {_Name = value;}
} private string _Name;

7. In Aspect-oriented programming (AOP), you can inject code into only Properties.

Using tools like AspectJ, can you do a pointcut only on properties in java? No, you cannot. You can do it on methods and filter it on methods that start with “get” or start with “set”, but we all know that get and set are only conventions and so any method that doesn’t follow convention won’t get the injected code (point cut in AspectJ), and worse, methods that aren’t getters or setters but start with get or set might get the pointcut, which is undesired.

8. Names of properties in a class match when doing Xml or Json serialization

Xml and Json serialization are very common. In C#, for newly developed code, there is no need to decorate the code with any C# Attributes as the names will serialize to JSON and Xml as is.

Imagine we want to get this following Xml from code.

<Person>
  <FirstName>Jared</FirstName>
  <LastName>Barneck</LastName>
</Person>

Or the following JSON.

{  
   "FirstName":"Jared",
   "LastName":"Barneck"
}

In C#, we create this poco class. Note: Poco = plain old class object.

public class Person
{
   public string FirstName { get; set; }
   public string LastName { get; set; }
}

In Java, the class is not so simple. There is not an easy or a guaranteed to work way to do this without a lot more code and without annotations. Here is the same object in Java and what you would have to do to have both getters and setters, private members and serialize using Simple. See my article on Java’s Simple Xml Serialization library.

public class Person
{
   @FirstName
   private String _FirstName {get;set;}
   public String getFirstName() { return _FirstName; }
   public void setFirstName(string value) { _FirstName = value; }

   @LastName
   private String _LastName {get;set;}
   public String getLastName() { return _LastName ; }
   public void setLastName(string value) { _LastName = value; }
}

So in Java, names don’t match, requiring the developer to add a fourth line, an annotation, just to make this work. And this is new code, not legacy code.

So when Java developers tell me that they don’t need properties, they are saying that they prefer four lines of code per property over one line per property when doing serialization. There is no argument. Of the two serializable class syntaxes above, C# is the winner by a long way.

Now some serializers other than Simple are made by using magic strings, where they hope that the get and set convention is used and if it is used, everything after the get or set is serialized. So getPerson() will serialize to Person. Still, this leaves the names not matching, and it requires magic strings of “get” and “set” and a hope (or requirement) that convention was followed.

C# also allows for taking of property of one name and serializing it to another name.

public class Person
{
   [XmlElement("fName")]
   public string FirstName { get; set; }
   [XmlElement("lName")]
   public string LastName { get; set; }
}

Yes, both C# and Java have this feature. The difference is, this is only needed to accommodate existing or legacy systems and not needed for brand new code and systems.

9. Names of properties in a class match when using a database ORM (or CSV or Excel headers)

Ok, this is almost an identical reason as #8, but serialization for JSON and Xml is vastly different than using a database ORM. But the same issue applies. And really Json and Xml are separate reasons and used often, so I could have broken those out into two features instead of one. But let’s not forget that this also benefits Excel output and CSV output as well as database table output. So, yes, this is a big, huge separate feature than serialization.

If you have a table:

CREATE TABLE [dbo].[User]
(
	[Id] [int] IDENTITY(1,1) NOT NULL,
	[Username] [nvarchar](255) NULL,
	[CreateDate] [datetime] NOT NULL,
	[LastUpdated] [datetime] NULL,
	[CreatedBy] [int] NOT NULL,
	[LastUpdatedBy] [int] NULL
)

With properties, the naming scheme matches exactly.

public class User
{
   public int Id { get; set; }
   public string Username { get; set; }
   public DateTime CreateDate { get; set; }
   public DateTime LastUpdated { get; set; }
   public int CreatedBy { get; set; }
   public int LastUpdatedBy { get; set; }
}

That is simple and pretty with the six members making up six lines. What do we do in Java?

public class Person
{   
   @Column(name = "Id")
   private String _Id {get;set;}
   public String getFirstName() { return _Id ; }
   public void setFirstName() { _Id = value; }

   @Column(name = "FirstName")
   private String _FirstName {get;set;}
   public String getFirstName() { return _FirstName; }
   public void setFirstName(string value) { _FirstName = value; }
   
   // Sorry, it is too tedious to even type out the rest of the java example, 
   // I would have to create 16 more lines of code for remaining four columns. Ugh!!!
}

10. Making convention a language construct and not just a convention

Multiple times, we have mentioned that trying to require the get and set convention and having tools key of magic strings (starts with “get” or starts with “set”) is not really a good practice. The convention cannot be enforced. I will say that Java has done a tremendous job of trying to enforce this convention. But in the end, it is still a questionable practice that keys off of magic strings that are not guaranteed to be there.

However, by implementing simpler properties, the convention goes away. Everyone who wants property features gets them. Tools no longer have to key off of magic strings.

One might argue that in C#, you can still write the Java way, by writing out getProperty() setProperty(Property value) methods, and that using Properties instead of methods is also only a convention. But that is not true and is shortsighted. Properties are properties. Whereas java only has two object members: member variables and methods; C# has three: member variables, properties, and methods. Properties are not just methods. As noted earlier, properties are separate in reflection, in a different list in the object type information. There is a clear and distinct difference between properties and methods and member variables and how they behave in C#. Because of this, magic strings are not needed to execute code.

Don’t just copy, improve too

Salesforce added C# like properties to Apex, their originally java-based language. Only they enhanced the properties by not requiring a separate backing field. In C#, if you call a property from the get, you create an infinite loop. In Apex, any calls to the variable inside the get don’t create an infinite loop. They copy and improved. Java should do the same.

From the Apex documentation on properties:

Apex properties are based on their counterparts in C#, with the following differences:

  • Properties provide storage for values directly. You do not need to create supporting members for storing values.
  • It is possible to create automatic properties in Apex. For more information, see Using Automatic Properties.

This is outdated information as C# has had the second item, auto properties, for many years now. However, C# doesn’t have the first improvement yet. Good job Salesforce and Apex. They didn’t just see a good thing and copy it, they saw it, copied it, and improved on it.

Properties Provide More Features

The benefits are many and far more valuable than Java developers or even most C# developer realize. The Pyramid analogy is really accurate. There are so many little features of C# properties that the sum of the feature set is, like sum of bricks in a pyramid, huge.

I surely missed many such features that properties provide.

What features do properties give you that would benefit the Java language?
What shorter syntaxes do properties give you over Java’s getter setter syntax?

Xamarin Free 4 All

We’ve been talking about the fact that Microsoft could make a huge move in enhancing the Windows App ecosystem simply by doing two things:

  1. Buy Xamarin
  2. Make it free

Recently, Microsoft bought Xamarin, checking off one of the two things they needed to do. I speculated on whether Microsoft would make Xamarin free for everyone. I believed that Microsoft would include Xamarin in different tiers for different levels of Visual Studio. But I noted that only by making it free for everyone, including the Visual Studio Community Edition Users, would Microsoft get the full community benefit.

They did it: Xamarin 4 all

Why you should avoid multiline string literals in C# with Git

Recently I started using Continuous Integration (CI) for my open source C# projects on GitHub. I found a http://www.AppVeyor.com would provide me this for free for my open source projects. I setup a few of my projects on the AppVeyor’s CI.

Unfortunately, one of my projects, Rhyous.EasyXml, failed four out of ten unit tests on the CI server. This made no sense. I had the code checked out on a work desktop and a laptop and all ten tests passed in both places.

I had a string that my EasyXml code generates. I had the expected Xml in the following multiline string literal.

        public string PrettyUtf8Xml =
@"<?xml version=""1.0"" encoding=""UTF-8""?>
<Person>
  <FirstName>John</FirstName>
  <MiddleName>Al Leon</MiddleName>
  <LastName>Doe</LastName>
</Person>";

The test results were not helpful because the string results in the test output were identical.

Starting test execution, please wait... 
Passed   TestMethodLinearize 
Failed   TestMethodPretty 
Error Message: 
   Assert.AreEqual failed. Expected:<<?xml version="1.0" encoding="UTF-8"?>
<Person>
  <FirstName>John</FirstName>
  <MiddleName>Al Leon</MiddleName>
  <LastName>Doe</LastName>
</Person>>. Actual:<<?xml version="1.0" encoding="UTF-8"?>
<Person>
  <FirstName>John</FirstName>
  <MiddleName>Al Leon</MiddleName>
  <LastName>Doe</LastName>
</Person>>.  
Stack Trace: 
   at Rhyous.EasyXml.Tests.XmlTests.TestMethodPretty() in C:\projects\easyxml\src\Unit Tests\Rhyous.EasyXml.Tests\XmlTests.cs:line 102

My first guess was that somehow my UTF-8 vs UTF-16 code wasn’t working and I set up to figure out how to compare the strings in a way that shows me the difference. I quickly found a wonderful string extension method ShouldEqualWithDiff for Unit Tests by Phil Haack. Phil Haack’s extension method is extremely helpful because it provides a verticle character by character output of the string if the comparison fails.

This provided the following output and pointed the finger of the problem directly at Git. See the highlighted lines 59 and 60 below that show that characters 38 and 39 fail to match up.

Failed   TestMethodPretty 
Error Message: 
   Assert.AreEqual failed. Expected:<<?xml version="1.0" encoding="UTF-8"?>
<Person>
  <FirstName>John</FirstName>
  <MiddleName>Al Leon</MiddleName>
  <LastName>Doe</LastName>
</Person>>. Actual:<<?xml version="1.0" encoding="UTF-8"?>
<Person>
  <FirstName>John</FirstName>
  <MiddleName>Al Leon</MiddleName>
  <LastName>Doe</LastName>
</Person>>.  
Stack Trace: 
   at Rhyous.EasyXml.Tests.StringExtensions.ShouldEqualWithDiff(String actualValue, String expectedValue, DiffStyle diffStyle, TextWriter output) in C:\projects\easyxml\src\Unit Tests\Rhyous.EasyXml.Tests\StringExtensions.cs:line 50
   at Rhyous.EasyXml.Tests.StringExtensions.ShouldEqualWithDiff(String actualValue, String expectedValue) in C:\projects\easyxml\src\Unit Tests\Rhyous.EasyXml.Tests\StringExtensions.cs:line 12
   at Rhyous.EasyXml.Tests.XmlTests.TestMethodPretty() in C:\projects\easyxml\src\Unit Tests\Rhyous.EasyXml.Tests\XmlTests.cs:line 102
Standard Output Messages: 
     Idx Actual    Expected
   -------------------------
     0   60   <    60   <  
     1   63   ?    63   ?  
     2   120  x    120  x  
     3   109  m    109  m  
     4   108  l    108  l  
     5   32   \u20;  32   \u20;
     6   118  v    118  v  
     7   101  e    101  e  
     8   114  r    114  r  
     9   115  s    115  s  
     10  105  i    105  i  
     11  111  o    111  o  
     12  110  n    110  n  
     13  61   =    61   =  
     14  34   "    34   "  
     15  49   1    49   1  
     16  46   .    46   .  
     17  48   0    48   0  
     18  34   "    34   "  
     19  32   \u20;  32   \u20;
     20  101  e    101  e  
     21  110  n    110  n  
     22  99   c    99   c  
     23  111  o    111  o  
     24  100  d    100  d  
     25  105  i    105  i  
     26  110  n    110  n  
     27  103  g    103  g  
     28  61   =    61   =  
     29  34   "    34   "  
     30  85   U    85   U  
     31  84   T    84   T  
     32  70   F    70   F  
     33  45   -    45   -  
     34  56   8    56   8  
     35  34   "    34   "  
     36  63   ?    63   ?  
     37  62   >    62   >  
   * 38  13   \r   10   \n 
   * 39  10   \n   60   <  
   * 40  60   <    80   P  
   * 41  80   P    101  e  
   * 42  101  e    114  r  
   * 43  114  r    115  s  
   * 44  115  s    111  o  
   * 45  111  o    110  n  
   * 46  110  n    62   >  
   * 47  62   >    10   \n 
   * 48  13   \r   32   \u20;
   * 49  10   \n   32   \u20;
   * 50  32   \u20;  60   <  
   * 51  32   \u20;  70   F  
   * 52  60   <    105  i  
   * 53  70   F    114  r  
   * 54  105  i    115  s  
   * 55  114  r    116  t  
   * 56  115  s    78   N  
   * 57  116  t    97   a  
   * 58  78   N    109  m  
   * 59  97   a    101  e  
   * 60  109  m    62   >  
   * 61  101  e    74   J  
   * 62  62   >    111  o  
   
   . . .

The cause is carriage returns. Why would AppVeyor’s tests have only \n while running the tests on any of my machines has \r\n? Yes, Git is the reason. Git normalizes carriage returns when you check in and check out your code. On a Windows box, \r\n is converted to \n on check-in. On checkout \n is converted to \r\n. When AppVeyor checks out my code, the conversion from \n to \r\n doesn’t occur.

So my options to fix this are these:

  1. Change Git to:
    1. use \r\n and not change line endings at all
    2. Change my code to be a single line string

    I chose the second option. I did not want to mess with the Git settings. Different people could have difference Git settings and if anyone else forked my code, and ran the tests, I wanted them to work. So I changed my code. Now the string literal is on one line and the new lines are indicated with \r\n.

            public string PrettyUtf8Xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<Person>\r\n  <FirstName>John</FirstName>\r\n  <MiddleName>Al Leon</MiddleName>\r\n  <LastName>Doe</LastName>\r\n</Person>";
    

    And now my Continuous Integration on AppVeyor is building and passing tests.

A simple C# factory class

I have a project that is pretty small. Despite the small size, it is well-designed, using multiple layers, and interfaces, dependency injection, and unit tests. I need to create a production object at runtime and a mocked object at test time. I could easily use an IOC container. The problem with that is that most IOC containers (Autoface, Castle Windsor, Unity, etc.) are larger than my entire project. While I am a proponent of using IOC containers in large projects, I’m not a big proponent of using them in very small projects.

To make my code more unit testable, I am using a project called SystemWrapper that wraps standard system calls in an Interface and a Wrapper. Again, because my project is small, I didn’t bring in the SystemInterfaces and SystemWrapper dlls. This wrapper includes an ISmtpClient and an SmtpClientWrap object and I only brought in those two class files. The business logic uses the interface, ISmtpWrapper. This allows for me to unit test it by injecting a mock ISmtpClient.

I needed a simple factory that creates a new SmptClient in production runtime but allows for my unit test to create and use a mock ISmptClient during unit test time.

Here is what my factory should do:

Production

  1. Create a new SmptClientWrap object (which wraps an System.Net.SmptClient oject).
  2. Use setting from the app.config or web.config for the mail server, domain, user, and password.

Unit Test

  1. Create an mock of ISmptClient (using Moq).

Here is the simple factory class that I wrote:

using System.Configuration;
using System.Net;
using SystemInterface.Net.Mail;
using SystemWrapper.Net.Mail;

namespace Rhyous.System.Factory
{
    public class SmtpClientFactory
    {
        public ISmtpClient GetNewSmtpClient()
        {
            return CreateCredentialsMethod();
        }

        public delegate ISmtpClient CreateCredentialsDelegate();

        public CreateCredentialsDelegate CreateCredentialsMethod = () => new SmtpClientWrap(ConfigurationManager.AppSettings["SmtpServer"])
        {
            Credentials = new NetworkCredential
            {
                Domain = ConfigurationManager.AppSettings["SmtpDomain"],
                UserName = ConfigurationManager.AppSettings["SmtpUser"],
                Password = ConfigurationManager.AppSettings["SmtpPassword"]
            }
        };
    }
}

In the above class, the GetNewSmptClient returns an ISmtpClient. I use a delegate to create a concrete ISmtpClient called SmtpClienWrap. The default delegate implementation gets the data from the app.config or web.config.

Now I can inject a concrete ISmtpClient into my code:

    using (var smtpClient = SmtpClientFactory.GetNewSmtpClient())
    {
        var mailer = new Mailer(smtpClient);
    }

Note: I could make SmptClientFactory static or make it a singleton. I’m thinking about both.

Now in a test, I am able to create a mock ISmtpClient. Here is an example.

        [TestMethod]
        public void ReplacingTheCreateCredentialsDelegateWorks()
        {
            var factory = new SmtpClientFactory();
            bool _wasCalled = false;
            factory.CreateCredentialsMethod = () =>
            {
                _wasCalled = true;
                return new Mock<ISmtpClient>().Object;
            };
            var client = factory.GetNewSmtpClient();
            Assert.IsTrue(_wasCalled);
        }

The one problem with my factory is that it is pretty specific to one class. It might be interesting to make it more generic.

using System;

namespace Rhyous.Factory
{
    public class ObjectFactory<TInterface, TObject>
        where TInterface : class
        where TObject : TInterface, new()
    {
        public TInterface GetNewObject()
        {
            if (!typeof(TInterface).IsInterface)
            {
                throw new Exception("The first generic, TInterface, must be an interface.");
            }
            return CreateObjectMethod();
        }

        public delegate TInterface CreateObjectDelegate();

        public virtual CreateObjectDelegate CreateObjectMethod
        {
            get
            {
                return _CreateObjectMethod ?? (_CreateObjectMethod = () => Activator.CreateInstance<TObject>());
            }
            set { _CreateObjectMethod = value; }
        }
        public CreateObjectDelegate _CreateObjectMethod;
    }
}

Now I move my delegate (which is creation method of the factory) upstream to where I instantiate the factory.

    var smtpClientFactory = smtpClientFactory = new ObjectFactory<ISmtpClient, SmtpClientWrap>
                    {
                        CreateObjectMethod = () => new SmtpClientWrap(ConfigurationManager.AppSettings["SmtpServer"])
                        {
                            Credentials = new NetworkCredential
                            {
                                Domain = ConfigurationManager.AppSettings["SmtpDomain"],
                                UserName = ConfigurationManager.AppSettings["SmtpUser"],
                                Password = ConfigurationManager.AppSettings["SmtpPassword"]
                            }
                        }
                    };

    // Then later use the factory...

    using (var smtpClient = smtpClientFactory.GetNewSmtpClient())
    {
        var mailer = new Mailer(smtpClient);
    }

Anyway, have fun with this mini-factory. It might be useful on small projects where you don’t want an entire IOC container.

The Oft Forgotten Middle Trim

Two Most Popular Ways to Trim

It has become ubiquitous to trim whitespace from data. Data should almost never have whitespace at the front or at the end. This fact is nearly ubiquitous throughout the industry.

  • Front Trim (also called left trim) = Remove leading whitespace, whitespace (space, tab, new line, carriage return) at the front of text.
  • Back Trim (also called left trim) = Remove trailing whitespace, whitespace (space, tab, new line, carriage return) from the back of data. Trailing whitespace.

What does this mean? Look at the following data example:

"  White space at front"      <-- space
"	White space at front" <-- tab
"
White space at front"         <-- new line or carriage return
"White space at back   "      <-- space
"White space at back	"     <-- tab
"White space at back
"                             <-- new line or carriage return

When extra white space is added to the front or back of data, it should almost always be trimmed.

The Third Way to Trim – Middle Trim

There is a third type of trimming that should be done for many fields. It is not as popular and many developers forget about it. (Marked in green below.)

  • Front Trim (also called left trim) = Remove whitespace (space, tab, new line, carriage return) from the front of data.
  • Back Trim (also called right trim) = Remove whitespace (space, tab, new line, carriage return) from the back of data.
  • Middle Trim (also called center trim) = Remove extra whitespace (space, tab, new line, carriage return) from between words of data.

Note: Extra whitespace could mean different things depending on the field. In this post, it means more than one space. However, if we were dealing with names of objects in code that should not have any middle spaces at all, then even one middle space could be considered an extra space.

Perhaps “Middle Trim” is not something you have heard of before. Front and back trim involves only removing characters if they exist. Middle Trim involves either removing or replacing characters if they exist. Because of this, some might argue that Middle Trim is an incorrect phrase. From a certain point of view, I would agree. However, to properly link the task to front trim and back trim, the phrase Middle Trim makes a lot of sense.

"Extra     white space in middle"      <-- space
"Extra 	white space in middle"          <-- tab
"Extra
white space in middle"         <-- new line or carriage return

This one actually takes some thought. Because it doesn’t apply to every field as often as front trim and back trim do. However, for many fields, middle trim is just as valid.

  • Address Lines (When there is one field per line)
  • City
  • Country
  • Name (Pretty much any type of name)
    • Account
    • Business
    • Contact
    • Company
    • Course
    • Customer
    • First
    • Last
    • Middle
    • Part
    • Partner
    • Product
    • School
    • Spouse
    • Street
    • User
  • Order Identifiers
  • State
  • etc…

Names should not have extra whitespace at the front, end, or middle. State or Country names should never have extra whitespace at the front, middle, or end. Many types of input should be cleaned of extra whitespace in the front, middle, or end.

"Awesome     Company LLC"  <-- space
"Washtington	D.C."      <-- tab
"United States of
America"                   <-- new line or carriage return

All of the above are wrong. I could quote First Normal Form to you, but really common sense should be enough. These spaces make the data wrong.

Now, each field may be different. You may not want middle trim if your field is a blob of text, that has paragraphs. In that case, you certainly want to leave carriage returns.

Implementing Middle Trim in C#

Middle trim isn’t exactly easy to implement. Some languages have features, such as Regex, which make it easy. Others do not.

Why isn’t Middle Trim extremely common and more easily implemented? Perhaps middle trim is forgotten because there isn’t a clear method for it like there is with String.Trim() and so it is often left out?

Many languages, like C#, make front and back trimming easy. In C#, you can simply call String.Trim() and it will trim whitespace from the front and back. However, it doesn’t clean up extra whitespace in the middle.

Doing all three trims in C# is most easily done with Regex and an extension method.

Note: Get the Rhyous.StringLibrary from NuGet or check out the Rhyous.StringLibrary project on GitHub.

public static class StringExtensions
{
    public static string TrimAll(this string value)
    {
        var newstring = value;
        newstring = myString.Trim(); // This removes extra whitespace from the front and the back.
        newstring = Regex.Replace(LastName, @"\s+", " "); // Replaces all whitespace with a single space
    }
}

If you want to avoid regex, you could roll your own like this:

public static class StringExtensions
{
    public static string TrimAll(this string value)
    {
        var trimmedValue = new StringBuilder();
        char previousChar = (char)0;
        foreach (char c in value)
        {
            if (char.IsWhiteSpace(c))
            {
                previousChar = c;
                continue;
            }
            if (char.IsWhiteSpace(previousChar) && trimmedValue.Length > 0)
            {
                trimmedValue.Append(' ');
            }
            trimmedValue.Append(c);
            previousChar = c;
        }
        return trimmedValue.ToString();
    }
}

You would use either method the same way.

  var newstring = " This string     has extra whitespace in the      front, middle and the end.   "
  newstring = nestring.TrimAll();

Implementing Middle Trim in MSSQL

MSSQL also has LTRIM (left trim) and RTRIM (right trim), but middle trim doesn’t exist. Middle Trim is even harder to write in MSSQL because there is no Regex. So you have to replace whitespaces characters with spaces, then remove multiple spaces.

Here is what it looks like to add a name to a person and to do all three trims: front, back, middle. Wow! It is ugly.

INSERT INTO PERSON  (NAME) VALUES (
	REPLACE(
		REPLACE (
			REPLACE(
				REPLACE(
					REPLACE(
						REPLACE(
							LTRIM(RTRIM(@str))
							, char(9), ' '
						),  char(10), ' '
					),  char(13), ' '
				),'  ',' '+CHAR(7)
			), CHAR(7)+' ',''
		), CHAR(7),''
	)
)

This does right trim, left trim. Then it replaces tabs, new line, and carriage returns with spaces. Then it uses the bell character (because bell is basically never used) to replace any double spaces, char(32)+Char(32), with space bell, char(32)+char(7). Then it replaces any instance of char(7)+char(32) with ”, an empty string. Then that might leave a few space bell sequences, so we only need one more replace of bell, char(7), with ”, an empty string.

How to know which type of trimming you need?

This is very simple. Just ask questions:

  • Front trim – Will extra whitespace at the front ever be valid?
  • Back trim – Will extra whitespace at the back ever be valid?
  • Middle trim – Will extra whitespace in the middle ever be valid? Are middle spaces allowed? If so, should they always be a single space?

If the answer to any of those questions is “no,” then you need to do that type of trim. However, it is clear that Middle Trim has more questions as it is more complex.

NuGet for Source Using Add As Link (Part 1)

Update: Projects using NuGet for Source with Add as Link. If you have a project using this please comment and let me know.

  1. https://github.com/rhyous/SimpleArgs
  2. https://github.com/rhyous/EasyXml
  3. https://github.com/rhyous/EasyCsv
  4. https://github.com/rhyous/SimplePluginLoader
  5. https://github.com/rhyous/StringLibrary

So I have a project on GitHub called SimpleArgs. This project makes command line arguments easy in a C# project. However, one of the requirements is to have an option to use the SimpleArgs dll or to have a single file executable. Yes, everything in one single exe, so referencing a dll is not an option.

So I created two separate NuGet packages from this project:

  1. SimpleArgs – This NuGet package uses a dll
  2. SimpleArgs.Sources – This NuGet package adds source

I use SimpleArgs.Sources the most. I quickly realized that NuGet for source does not scale. I have a Solution with four different projects where each project is a single file executable. The result was many copies of the SimpleArgs code.

MySolution
    /Packages    &amp;lt;-- Copy of SimpleArgs source
    /SingleExe1  &amp;lt;-- Copy of SimpleArgs source
    /SingleExe2  &amp;lt;-- Copy of SimpleArgs source
    /SingleExe3  &amp;lt;-- Copy of SimpleArgs source
    /SingleExe4  &amp;lt;-- Copy of SimpleArgs source

That is 5 copies of the SimpleArgs source. Now at first, this doesn’t seem to be a big problem, in fact, it seems little more than an annoyance. One of the first changes I made, was to exclude the duplicate copies of source from Git. This helped but not enough. There are still problems that occur with multiple copies of source. For example, I ran into a bug with SimpleArgs. I fixed it, and then some time later I ran into the same bug with another project in the same solution. Oh, yeah. I only fixed the bug in one copy of the SimpleArgs source.

I decided the best solution was to reference the source using Add as link. Add as link is the ability to include a file into your Visual Studio project but without making a copy of the file in your project.

See: How to Add As Link in Visual Studio

I quickly changed the projects so the source was included not as copies but using the Add As Link capability. I manually did this. Then I finally pushed my changes to SimpleArgs Git repository and released a new version of the SimpleArgs.Sources NuGet package. That basically wiped out my manual work to Add As Link.

I needed the NuGet packages include the source using Add As Link for me.

How to create NuGet package using Add As Source

Well, to my dismay, NuGet didn’t have this feature built in. At first I was exciting about the possibility that this feature would be added as part of NuGet 3.3 and the contentFiles feature, but unfortunately, this feature is for Universal Windows projects, and not for Console Application, Windows Forms, or WPF projects.

However, NuGet does run a PowerShell script on install and another on uninstall, called install.psi and uninstall.ps1. It took some work, I even gave up once, but eventually I found the right library and the documentation for it to help me solve this.

Step 1 – Create a NuGet Packager Project in Visual Studio

  1. Open Visual Studio and go to File | New Project.
    Note: Steps 2 thru 7 installs the NuGet Packager project from online. If you have already done this, then you probably can create your project without these steps. 🙂
  2. At the bottom of the list on the right, click Online to expand it.
    Note: For some reason, Visual Studio hung for about ten to twenty seconds when I clicked this.
  3. In the search bar on the top right, enter NuGet.
  4. Select NuGet Packager.
  5. Give your project a Name.
    Note: Mine is named SimpleArgs.Sources.
  6. Give your solution a Name.
  7. Click Ok.
    See steps 2 – 7 in this image:
    NuGet Package Visual Studio Project Template
    When you click OK, the template will install. It will prompt you a few times but once installed, your project will be created.Note: From now on, you can find the NuGet Packager project in Installed | Templates | Visual C# | NuGet.

Step 2 – Fill out the Package.nuspec file metadata

The package.nusepc is an Xml file. It is created as follows:

 
&amp;lt;?xml version=&amp;quot;1.0&amp;quot;?&amp;gt;
&amp;lt;package &amp;gt;
  &amp;lt;metadata&amp;gt;
    &amp;lt;id&amp;gt;SimpleArgs.Sources&amp;lt;/id&amp;gt;
    &amp;lt;version&amp;gt;1.0.0&amp;lt;/version&amp;gt;
    &amp;lt;title&amp;gt;SimpleArgs.Sources&amp;lt;/title&amp;gt;
    &amp;lt;authors&amp;gt;Jjbarneck&amp;lt;/authors&amp;gt;
    &amp;lt;owners&amp;gt;&amp;lt;/owners&amp;gt;
    &amp;lt;description&amp;gt;A long description of the package. This shows up in the right pane of the Add Package Dialog as well as in the Package Manager Console when listing packages using the Get-Package command.&amp;lt;/description&amp;gt;
    &amp;lt;releaseNotes&amp;gt;&amp;lt;/releaseNotes&amp;gt;
    &amp;lt;summary&amp;gt;A short description of the package. If specified, this shows up in the middle pane of the Add Package Dialog. If not specified, a truncated version of the description is used instead.&amp;lt;/summary&amp;gt;
    &amp;lt;language&amp;gt;en-US&amp;lt;/language&amp;gt;
    &amp;lt;projectUrl&amp;gt;https://nuget.org/packages/SimpleArgs.Sources&amp;lt;/projectUrl&amp;gt;
    &amp;lt;iconUrl&amp;gt;https://nuget.org/Content/Images/packageDefaultIcon-50x50.png&amp;lt;/iconUrl&amp;gt;
    &amp;lt;requireLicenseAcceptance&amp;gt;false&amp;lt;/requireLicenseAcceptance&amp;gt;
    &amp;lt;licenseUrl&amp;gt;http://opensource.org/licenses/Apache-2.0&amp;lt;/licenseUrl&amp;gt;
    &amp;lt;copyright&amp;gt;Copyright  2016&amp;lt;/copyright&amp;gt;
    &amp;lt;dependencies&amp;gt;
        &amp;lt;group targetFramework=&amp;quot;net40&amp;quot;&amp;gt;
          &amp;lt;dependency id=&amp;quot;log4net&amp;quot; version=&amp;quot;1.2.10&amp;quot; /&amp;gt;
        &amp;lt;/group&amp;gt;
    &amp;lt;/dependencies&amp;gt;
    &amp;lt;references&amp;gt;&amp;lt;/references&amp;gt;
    &amp;lt;tags&amp;gt;&amp;lt;/tags&amp;gt;
  &amp;lt;/metadata&amp;gt;
  &amp;lt;files&amp;gt;
    &amp;lt;file src=&amp;quot;lib\&amp;quot; target=&amp;quot;lib&amp;quot; /&amp;gt;
    &amp;lt;file src=&amp;quot;tools\&amp;quot; target=&amp;quot;tools&amp;quot; /&amp;gt;
    &amp;lt;file src=&amp;quot;content\&amp;quot; target=&amp;quot;content&amp;quot; /&amp;gt;
  &amp;lt;/files&amp;gt;
&amp;lt;/package&amp;gt;
Package.nuspec Changes

I can’t go over every possible nuspec setting. That is in the Nuspec Reference. However, I’ll give you the basics of what I changed.

  1. id – Set this to your package name. If you named your project correctly, this is already named correctly. I’ll leave the above unchanged.
  2. version – This is your version. If this is your first release, 1.0.0 is perfect. I am changing mine to 1.1.0 as my last version was 1.0.9.
  3. title – Often the same as the id, but not always. I’ll leave mine as is.
  4. authors – This is me. I want something other than the Visual Studio username. I changed this to Jared Barneck (Rhyous)
  5. owners – This is me or my business. I’ll change this to Rhyous Publishing LLC
  6. description – Long description. This is defined in the Xml. Change it to describe your NuGet package.
  7. releaseNotes – I just put a link to the release notes in my GitHub repo: https://github.com/rhyous/SimpleArgs/blob/master/ReleaseNotes.txt
  8. summary – Short description. This is also defined in the xml. This is usually shorter than the description.
  9. language – This is the 5 digit language IETF language tag. I left mine at en-US.
  10. projectUrl – I changed this to my GitHub location: https://github.com/rhyous/SimpleArgs
  11. iconUrl – I changed this to the icon file in my GitHub source. Unlike the release notes and the license file, I used the raw GitHub link for the image: https://raw.githubusercontent.com/rhyous/SimpleArgs/master/Docs/Images/SimpleArgs.Logo.png
  12. requireLicenseAcceptance – I left this as false. Only set this to true if your license requires an agreement.
  13. licenseUrl – I set this to the license file in my GitHub repository:
    https://github.com/rhyous/SimpleArgs/blob/master/Fork%20and%20Contribute%20License.txt
  14. copyright – I set this to Copyright Rhyous Publishing LLC
  15. dependencies – This project has no dependencies, so I deleted this entire section.
  16. references – I deleted this tag. Source NuGet packages probably won’t have any references.
  17. tags – Since my project is for command line arguments, I set my tags to: args, arguments
  18. files – This was preconfigured, however, I replaced the libs\ with src\ because I didn’t have any libs but I have source.

You can see my final nuspec file in the GitHub repo: SimpleArgs.Sources Package.nuspec

Step 3 – Add Shared Source Files

Default Items in Solution Explorer for a NuGet Packager ProjectIn Visual Studio, in Solution Explorer, you should see that there are already four folders provided for you. See the image to your right. ———–>

  • content – This is what is going to be copied to your project. Since we don’t want all our source copied, we aren’t going to put our source here.
    Note: I would delete this folder, but it turns out, I have one source file that isn’t shared. ArgsHandler.cs will be customized in each project, which makes sense because each project will have different args and handle args differently. ArgsHandler.cs will go here.
  • libs – I have no libs. I can delete this folder and the associated xml for it in the nuspec.
  • src – Stuff I put here isn’t copied to my projects. I am going to put all my shared source in this folder.
  • tools – this has the PowerShell scripts: init.ps1, install.ps1, and uninstall.ps1

Now that we understand our folder structure, let’s get to work.

  1. In Visual Studio’s Solution Explorer, create a folder called App_Packages under the src directory.
    Note: I was going to use App_Sources but NuGet recommends that we follow what other community members follow and others have already started putting source files under App_Packages, so I am following that community convention. Also, this is important for the PowerShell scripts, as this convention plays a part in them. If you don’t follow this convention, you will have to edit the and uninstall.psi PowerShell scripts, which I’ll be providing later.
  2. In Visual Studio’s Solution Explorer, create a Folder with the project name and version. In my case, the folder name is this: SimpleArgs.Sources.1.1.0.
    Note: Again, this was by community convention. Others were doing this. You don’t have to follow this exactly, again, If you don’t follow this convention, you will have to edit the install.ps1 and uninstall.psi PowerShell scripts, which I’ll be providing later.
  3. In Windows Explorer, not in Visual Studio, put your source under the project name and version directory.
    Note: In Visual Studio’s Solution Explorer, I only have these two directories: App_Packages/SimpleArgs.Sources.1.1.0.
    Note: In Windows Explorer, My directory structure ended up as follows:

    \App_Packages
    \App_Packages\SimpleArgs.Sources.1.1.0\
    \App_Packages\SimpleArgs.Sources.1.1.0\Business
    \App_Packages\SimpleArgs.Sources.1.1.0\Business\Args.cs
    \App_Packages\SimpleArgs.Sources.1.1.0\Business\ArgsHandlerCollection.cs
    \App_Packages\SimpleArgs.Sources.1.1.0\Business\ArgsManager.cs
    \App_Packages\SimpleArgs.Sources.1.1.0\Business\ArgsReader.cs
    \App_Packages\SimpleArgs.Sources.1.1.0\Business\ArgumentMessageBuilder.cs
    \App_Packages\SimpleArgs.Sources.1.1.0\Business\CommonAllowedValues.cs
    \App_Packages\SimpleArgs.Sources.1.1.0\Extensions
    \App_Packages\SimpleArgs.Sources.1.1.0\Extensions\ArgumentExtensions.cs
    \App_Packages\SimpleArgs.Sources.1.1.0\Extensions\StringExtensions.cs
    \App_Packages\SimpleArgs.Sources.1.1.0\Interfaces
    \App_Packages\SimpleArgs.Sources.1.1.0\Interfaces\IArgumentMessageBuilder.cs
    \App_Packages\SimpleArgs.Sources.1.1.0\Interfaces\IArgumentsHandler.cs
    \App_Packages\SimpleArgs.Sources.1.1.0\Interfaces\IReadArgs.cs
    \App_Packages\SimpleArgs.Sources.1.1.0\Model
    \App_Packages\SimpleArgs.Sources.1.1.0\Model\Argument.cs
    \App_Packages\SimpleArgs.Sources.1.1.0\Model\ArgumentAddedEventArgs.cs
    \App_Packages\SimpleArgs.Sources.1.1.0\Model\ArgumentDictionary.cs
    \App_Packages\SimpleArgs.Sources.1.1.0\Model\ArgumentList.cs
    \App_Packages\SimpleArgs.Sources.1.1.0\Model\ArgumentsHandlerBase.cs
    

    Note: There is a good reason that I don’t include these in the NuGet Packager Visual Studio project, which I will explain later.

Step 4 – Add Source Files

As mentioned earlier, the ArgsHandler.cs file isn’t shared. Each project does need its own copy of this file. So we need to add it so that it supports Source Code Transformations.

  1. In Visual Studio’s Solution Explorer, copy any source files into the Content directory. You may put them in sub directories if you wish. I created an Arguments folder.
  2. Add .pp to the end of any source files.
  3. Change the namespace to $rootnamespace$ in any source files. You may also add a sub namespace to the end of $rootnamespace$ as I did.
using SimpleArgs;
using System;
using System.Collections.Generic;

namespace $rootnamespace$.Arguments
{
    // Add this line of code to Main() in Program.cs
    //
    //   ArgsManager.Instance.Start(new ArgsHandler(), args);
    //

    /// &amp;lt;summary&amp;gt;
    /// A class that implements IArgumentsHandler where command line
    /// arguments are defined.
    /// &amp;lt;/summary&amp;gt;
    public sealed class ArgsHandler : ArgsHandlerBase
    {
         // content snipped see full file here: https://github.com/rhyous/SimpleArgs/blob/master/NuGet/SimpleArgs.NuGet/content/Arguments/ArgsHandler.cs.pp
    }
}

Step 5 – Add As Link in NuGet using PowerShell scripts

There are three PowerShell scripts.

  • init.ps1
  • install.ps1
  • uninstall.ps1

We are only going to modify install.ps1 and uninstall.ps1.

Note: The following are written to be very generic and have been tested in various Visual Studio projects, which means some common bugs are already fixed, such as not failing on creation of App_Packages just because it is already there.

  1. Update install.ps1.

    Note: For the latest versions of install1.ps1 and uninstall.ps1, go to the tools directory on my GitHub repo.

    # Runs every time a package is uninstalled
    
    param($installPath, $toolsPath, $package, $project)
    
    # $installPath is the path to the folder where the package is installed.
    # $toolsPath is the path to the tools directory in the folder where the package is installed.
    # $package is a reference to the package object.
    # $project is a reference to the project the package was installed to.
    
    # Variables
    $src = &amp;quot;src&amp;quot;
    $packageName = [System.IO.Path]::GetFileName($installPath)
    
    #logging
    write-host &amp;quot;project: &amp;quot; $project.FullName
    write-host &amp;quot;installPath: &amp;quot; $installPath
    write-host &amp;quot;toolsPath: &amp;quot; $toolsPath
    write-host &amp;quot;package: &amp;quot; $package
    write-host &amp;quot;project: &amp;quot; $project
    
    $srcPath = [System.IO.Path]::Combine($installPath, $src)
    write-host &amp;quot;srcPath: &amp;quot; $srcPath
    
    $solutionDir = [System.IO.Path]::GetDirectoryName($dte.Solution.FullName)
    $projectDir = [System.IO.Path]::GetDirectoryName($project.FullName)
    write-host &amp;quot;solutionDir: &amp;quot; $solutionDir
    write-host &amp;quot;projectDir: &amp;quot; $projectDir
    
    $areSameDir = $solutionDir -eq $projectDir
    write-host &amp;quot;areSameDir: &amp;quot; $areSameDir
    
    function AddLinkedFiles($path, $addLocation, $canLink) 
    { 
        write-host &amp;quot;path: &amp;quot; $path
        write-host &amp;quot;addLocation: &amp;quot; $addLocation.FullName
        write-host &amp;quot;canLink: &amp;quot; $canLink
        foreach ($item in Get-ChildItem $path)
        {
            write-host &amp;quot;item: &amp;quot; $item $item.FullName
            if (Test-Path $item.FullName -PathType Container) 
            {
                if ( $canLink) {
                    $addFolder = $project.ProjectItems|Where-Object {$_.FullName -eq $item.FullName}
                    if (!$addFolder) {
                        $addFolder = $addLocation.ProjectItems.AddFolder($item)
                    }
                    write-host &amp;quot;addFolder: &amp;quot; $addFolder.FullName
                    AddLinkedFiles $item.FullName $addFolder $canLink
                } else
                {
                    AddLinkedFiles $item.FullName $addLocation $canLink
                }            
            } 
            else 
            {             
                write-host &amp;quot;Adding &amp;quot; $item.FullName &amp;quot; to &amp;quot; $addLocation.FullName
                $addLocation.ProjectItems.AddFromFile($item.FullName)
            }
        } 
    }
    
    write-host &amp;quot;Calling AddLinkedFiles&amp;quot;
    AddLinkedFiles $srcPath $project (!$areSameDir)
    
  2. Update uninstall.ps1.
    # Runs every time a package is uninstalled
    
    param($installPath, $toolsPath, $package, $project)
    
    # $installPath is the path to the folder where the package is installed.
    # $toolsPath is the path to the tools directory in the folder where the package is installed.
    # $package is a reference to the package object.
    # $project is a reference to the project the package was installed to.
    
    # Variables
    $packages = &amp;quot;Packages&amp;quot;
    $app_packages = &amp;quot;App_Packages&amp;quot;
    $src = &amp;quot;src&amp;quot;
    $packageName = [System.IO.Path]::GetFileName($installPath)
    
    #logging
    write-host &amp;quot;project: &amp;quot; $project.FullName
    write-host &amp;quot;installPath: &amp;quot; $installPath
    write-host &amp;quot;toolsPath: &amp;quot; $toolsPath
    write-host &amp;quot;package: &amp;quot; $package
    write-host &amp;quot;project: &amp;quot; $project
    
    
    $srcPath = [System.IO.Path]::Combine($installPath, $src)
    write-host &amp;quot;srcPath: &amp;quot; $srcPath
    
    $solutionDir = [System.IO.Path]::GetDirectoryName($dte.Solution.FullName)
    $projectDir = [System.IO.Path]::GetDirectoryName($project.FullName)
    write-host &amp;quot;solutionDir: &amp;quot; $solutionDir
    write-host &amp;quot;projectDir: &amp;quot; $projectDir
    
    $areSameDir = $solutionDir -eq $projectDir
    write-host &amp;quot;areSameDir: &amp;quot; $areSameDir
    
    
    if ($areSameDir) {
        $packagesItem = $project.ProjectItems|Where-Object {$_.Name -eq $packages}    
        write-host &amp;quot;packageFolder: &amp;quot; $packagesItem.Name
        $item = $packagesItem.ProjectItems|Where-Object {$_.Name -eq [System.IO.Path]::GetFileName($installPath)}
        write-host &amp;quot;item: &amp;quot; $item.Name
        $item.Remove()
        if ($packagesItem.ProjectItems.Count -eq 0) {
            $packagesItem.Remove()
        }            
    } else {
        $app_packagesItem = $project.ProjectItems|Where-Object {$_.Name -eq $app_packages}
        write-host &amp;quot;app_packagesItem: &amp;quot; $app_packagesItem.Name
        $app_packagesFolder = [System.IO.Path]::Combine($srcPath,$app_packages)
        foreach ($subDir in (Get-ChildItem $app_packagesFolder)) {
            $item = $app_packagesItem.ProjectItems|Where-Object {$_.Name -eq $subDir.Name}
            write-host &amp;quot;item: &amp;quot; $item.Name
            if ($item) {
                $item.Delete()
            }
        }
        if ($app_packagesItem.ProjectItems.Count -eq 0 -and (Get-ChildItem ([System.IO.Path]::Combine($projectDir, $app_packages))).Count -eq 0) {
            $app_packagesItem.Delete()
        }
    }
    

    Step 6 – Build the solution and NuGet package

    The NuGet Packager project template is pretty awesome. When you use it, it builds the NuGet package for you on build. Also, if you build in release mode, it will try to upload the NuGet package to the public NuGet Package Gallary.

    1. In Visual Studio, make sure the Solution Configuration is set to Debug.
    2. Choose to Build | Build Solution.
    3. In your project directory, you should have a NuGet package built. Mine is called SimpleArgs.Sources.1.1.1.nupkg.

    Stay Tuned

    Stay tuned for NuGet for Source Using Add As Link (Part 2 – Testing & Deploying)

    If you subscribe, you will never miss a post.

Microsoft to Acquire Xamarin

XamarinMicrosoft is to acquire Xamarin. Read the article here. Xamarin is far and away the best tool for writing cross-platform mobile apps, but their business model greatly slowed the company’s customer acquisition.

A new mobile developer could easily install Eclipse for free and develop a mobile app without zero cost. The minimum Xamarin fee cost $25 a month but it did not work with Visual Studio. The minimum Xamarin version that worked with Visual Studio cost $1000 a month.

Better business models existed. I long recommended that Xamarin be completely free to for developers to download and use, but the compiled code should have been time-bombed for one day. Of course, with IL editors such time-bombing could be removed, but doing so would not be easy. This model would have allowed them to gather all the indie developers who had an idea and quickly get their application to work on iOS, Android, and Windows. Then at release time, charging a fee to publish the app would have been more palatable. In the long run it would have resulted in more customers and users. It would have skyrocketed the number of xamarin developers. I believe Xamarin would have ended up making far more money by charging less to way more users. But Xamarin disagreed.

Microsoft sees the need to make Xamarin the go to language from cross-platform apps. The flaky and hacked together html5 stack is the only other option for true cross-platform development. Microsoft and Visual Studio has a marge larger user base than Xamarin. If Microsoft’s intention to maintain Xamarin’s model, they would be making a huge mistake.

Microsoft should immediately add Xamarin to the Visual Studio Enterprise subscribers. Enterprise is the top-level and should get everything. There will be some loss of revenue as some Xamarin customers are also Enterprise subscribers, but that loss in negligible and would probably be made up by higher renewal rates and less downgrades. However, if Miocrosoft were to add all of Xamarin also to their Visual Studio Professional subscribers, Xamarin might lose a huge portion of revenue, as most Xamarin customers are also Visual Studio Subscribers. If they want to keep this revenue, then they could easily add a mobile subscription level for mobile only developers and then a professional plus mobile subscription level entices current professional developers to upgrade.

However, what if Microsoft doesn’t care about Xamarin’s revenue at all. What if what they care about is getting mobile developers to primarily use Visual Studio. What if they give Xamarin in its entirety away free in Community Edition so everyone at any Visual Studio level would have it. And what if they open source it?

How many more users would flock to Visual Studio Community Edition? This could be the catalyst to dethrone JavaScript. To bring thousands of users to the Microsoft development ecosystem that also includes Azure. What types of increases in their cloud users could this bring? Perhaps the Xamarin acquistion is not intended to continue to make its own revenue. Perhaps the acquisition is nothing more than a feature add to their existing technology stack.

Were I Microsoft’s CEO, Satya Nadella, I would go the Community Edition route. But I’m not him and I do not know what he is going to do. We are left to wait and see.

 

How to easily access a web.config AppSettings value with a Type and a default value?

Update: This is now in my Rhyous.Collections NuGet package and you can see the source on GitHub: NameValueCollectionExtensions.cs

I wanted to make it easier to get a value from AppSettings in the web.config (or the app.config if you aren’t doing web) while converting to the proper type and having a default value.

Here is the syntax I started with that I didn’t like at all.

public static int MaxRetryAttempts = (string.IsNullOrWhiteSpace(ConfigurationManager.AppSettings["SmptRetries"]))
    ? int.Parse(ConfigurationManager.AppSettings["SmptRetries"])
    : 3;

I decided I wanted to have the following syntax:

ConfigurationManager.AppSettings.Get<T>(string key, T defaultValue)

I found a blog post that got me started. His syntax was very close to what I wanted already. He didn’t have the default value and he wasn’t an extension method, but wow, was this a real help. I was unaware of TypeDescriptor.GetConverter and was going to basically roll my own with an massively ugly case statement. So I am very happy I found his post.

I created the following NameValueCollectionExtensions.cs file.

using System.Collections.Specialized;
using System.ComponentModel;

namespace Rhyous.Extensions
{
    public static class NameValueCollectionExtensions
    {
        public static T Get<T>(this NameValueCollection collection, string key, T defaultValue)
        {
            var value = collection[key];
            var converter = TypeDescriptor.GetConverter(typeof(T));
            if (string.IsNullOrWhiteSpace(value) || !converter.IsValid(value))
            {
                return defaultValue;
            }

            return (T)(converter.ConvertFromInvariantString(value));
        }
    }
}

Details

  1. ConfigurationManager.AppSettings is of Type System.Collections.Specialized.NameValueCollection. So my extension method must be for that type.
  2. I changed the author’s method to be an extension method using the “this” keyword.
  3. I changed from using ConfirationManager.AppSettings to use the first parameter, collection, defined by the “this” keyword.
  4. I added a parameter for a default value.
  5. I changed the method code to return the default value, instead of throwing an exception, if the setting in the web.config is missing or empty.

Usage

I have to retry sending emails. I want the SmtpRetries to be an int obtained from the web.config’s AppSettings and have a default value of 3.

public static int MaxRetryAttempts = ConfigurationManager.AppSettings.Get("SmptRetries", 3);

Unit Tests

I really only wrote unit tests for int conversion. I expect that is sufficient. But if you want to write tests for a double or a other type feel free.

using System;
using System.Collections.Specialized;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace Rhyous.Extensions.Tests
{
    [TestClass]
    public class NameValueCollectionExtensionsTests
    {
        private const string Name = "Retries";

        [TestMethod]
        public void IntValueExistsTest()
        {
            // Arrange
            const int defaultMaxRetries = 2;
            const int value = 3;
            var collection = new NameValueCollection { { Name, value.ToString() } };

            // Act
            var actual = collection.Get(Name, defaultMaxRetries);

            // Assert
            Assert.AreEqual(value, actual, "Valid value should return the valid value.");
        }

        [TestMethod]
        public void IntValueDoesNotExistTest()
        {
            // Arrange
            const int defaultMaxRetries = 2;
            var collection = new NameValueCollection();

            // Act
            var actual = collection.Get(Name, defaultMaxRetries);

            // Assert
            Assert.AreEqual(defaultMaxRetries, actual, "Missing value returns default.");
        }

        [TestMethod]
        public void IntValueIsEmptyStringTest()
        {
            // Arrange
            const int defaultMaxRetries = 2;
            var collection = new NameValueCollection { { Name, string.Empty } };

            // Act
            var actual = collection.Get(Name, defaultMaxRetries);

            // Assert
            Assert.AreEqual(defaultMaxRetries, actual, "Empty string returns default.");
        }

        [TestMethod]
        public void IntValueIsWhiteSpaceStringTest()
        {
            // Arrange
            const int defaultMaxRetries = 2;
            var collection = new NameValueCollection { { Name, "  " } };

            // Act
            var actual = collection.Get(Name, defaultMaxRetries);

            // Assert
            Assert.AreEqual(defaultMaxRetries, actual, "Whitespace string returns default.");
        }

        [TestMethod]
        public void IntValueIsDoubleTest()
        {
            // Arrange
            const int defaultMaxRetries = 2;
            const double value = 3.5; 
            var collection = new NameValueCollection { { Name, value.ToString() } };

            // Act
            var actual = collection.Get(Name, defaultMaxRetries);

            // Assert
            Assert.AreEqual(defaultMaxRetries, actual, "Invalid value returns default.");
        }

        [TestMethod]
        public void IntValueIsCharsTest()
        {
            // Arrange
            const int defaultMaxRetries = 2;
            const string value = "abc";
            var collection = new NameValueCollection { { Name, value } };

            // Act
            var actual = collection.Get(Name, defaultMaxRetries);

            // Assert
            Assert.AreEqual(defaultMaxRetries, actual, "Invalid value returns default.");
        }
    }
}

Authentication Token Service for WCF Services (Part 6 – A JavaScript client)

Drum roll please . . . This is the moment you’ve all been waiting for. The JavaScript client has finally arrived. In the past articles we have taken control of Authentication in WCF. The token authentication service was designed specifically for ReST like WCF services to be used by modern web and mobile apps. For modern web, that means the Basic Token Service for WCF Services has to work with JavaScript! Of course, it does. That is what it was designed for.

As for the WCF Services, I made a few improvements and fixed some bugs. I am not going to go over those changes. Just know it is a better example than what was delivered in part 6, but not much different.

Download this project here: WCF BTS JS Client

OK. So here is my little html and javascript example. I created a single html file, mostly. I added jquery and knockoutjs from NuGet. The rest is all in the TestPage/Index.html. Really, all you need to know is that there are three buttons. One to test authentication, one to test using the token for calling the test service, and one for using Basic Authentication instead of the token to call the test service.

Here is an image of the page rendered in a browser.

AuthenticationTokenService html and JavaScript

Here is the source code.

<!DOCTYPE html>
<html>
<head>
    <title>JavaScript Client</title>
    <meta charset="utf-8" />
    <script type="text/javascript" src="/Scripts/jquery-2.1.4.js"></script>
    <script type="text/javascript" src="/Scripts/knockout-3.4.0.debug.js"></script>
    <script type="text/javascript">
        var ViewModel = function () {
            var _vm = this;
            _vm.user = ko.observable();
            _vm.password = ko.observable();
            _vm.basicAuth = ko.computed(function () {
                return "Basic " + btoa(_vm.user() + ":" + _vm.password());
            });
            // I am just sticking the token in a local variable,
            // but you might want to save it in a cookie.
            _vm.token = ko.observable();
            _vm.getResponse = ko.observable();
            _vm.postResponse = ko.observable();
            _vm.onAuthClick = function () {
                $.ajax({
                    method: "POST",
                    url: "/Services/AuthenticationTokenService.svc/Authenticate",
                    contentType: "application/json",
                    context: document.body,
                    data: JSON.stringify({
                        User: _vm.user(),
                        Password: _vm.password()
                    }),
                    success: function (data) {
                        _vm.token(data);
                    },
                    failure: function (err) { alert(err.responseText); },
                    error: function (err) { alert(err.responseText); }
                });
            };
            _vm.onTestGetWithTokenClick = function () {
                $.ajax({
                    url: "/Services/Test1Service.svc/TestGet",
                    contentType: "application/json",
                    context: document.body,
                    beforeSend: function (request) { request.setRequestHeader("Token", _vm.token()); },
                    success: function (data) {
                        _vm.getResponse(data);
                    },
                    failure: function (err) { alert(err.responseText); },
                    error: function (err) { alert(err.responseText); }
                });
            };
            _vm.onTestPostWithBasicAuthClick = function () {
                $.ajax({
                    method: "POST",
                    url: "/Services/Test1Service.svc/TestPost",
                    contentType: "application/json",
                    context: document.body,
                    beforeSend: function (request) { request.setRequestHeader("Authorization", _vm.basicAuth()); },
                    success: function (data) {
                        _vm.postResponse(data);
                    },
                    failure: function (err) { alert(err.responseText); },
                    error: function (err) { alert(err.responseText); }
                });
            };
        };
        $(function () {
            ko.applyBindings(new ViewModel());
        });
    </script>
</head>
<body>
    <div>
        <input type="text" data-bind="value: user" placeholder="Enter your username here . . ." />
        <input type="password" data-bind="value: password" placeholder="Enter your password here . . ." />
        <input type="button" value="Authenticate" data-bind="click: onAuthClick" />
    </div>
    <p>Token: <span data-bind="text: token"></span></p>
    <input type="button" value="Test Get w/ Token" data-bind="click: onTestGetWithTokenClick" />
    <p>Test Get Response: <span data-bind="text: getResponse"></span></p>
    <input type="button" value="Test Post w/ Basic Auth" data-bind="click: onTestPostWithBasicAuthClick" />
    <p>Test Post Response: <span data-bind="text: postResponse"></span></p>
</body>
</html>

Authentication Token Service for WCF Services (Part 5 – Adding SSL)

In the previous article, Basic Token Service for WCF Services (Part 4 – Supporting Basic Authentication), we implemented Basic Authentication. And in the articles before that, our credentials were in the body of the http request. That means we have a huge security issue. Credentials are passing as clear text. This is very, very, very (insert a few thousand more very’s) bad. We need to enabled SSL.

I am going to assume that you know how to do this in production on IIS. I am going to show you how to do this in your development environment.

See this project on GitHub here: https://github.com/rhyous/Auth.TokenService

Setting Up Visual Studio for SSL

First, let’s get this working in your project. Visual Studio uses needs to launch your project in IIS Express as an SSL site.

  1. In Visual Studio, highlight your project in Solution Explorer.
  2. Press F4 to get the project properties.
  3. Set SSL to true. Notice an SSL url is created on a new port.
ProjectProperties

Setting Up Web Services for SSL

The web.config is where the WCF endpoints are configured. They are currently configured only for HTTP and not HTTPS. So let’s make some web.config edits.

  1. Add an Binding configuration with the security mode set to Transport.
  2. So set the clientCredentialType to none. Remember, we are not using IIS to handle authentication, but instead, we are handling authentication in the service.
  3. use webHttpBinding because We are using JSON and ReST-like (not full ReST) WCF services.
  4. Configure the endpoints to use the newly created Binding configuration.

Here is the complete web.config. The changed or added lines are highlighted.
Changed: Lines 17, 20
Added: Lines 47-55

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <configSections>
    <!-- For more information on Entity Framework configuration, visit http://go.microsoft.com/fwlink/?LinkID=237468 -->
    <section name="entityFramework" type="System.Data.Entity.Internal.ConfigFile.EntityFrameworkSection, EntityFramework, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" requirePermission="false" />
  </configSections>
  <appSettings>
    <add key="aspnet:UseTaskFriendlySynchronizationContext" value="true" />
  </appSettings>
  <system.web>
    <compilation debug="true" targetFramework="4.5" />
    <httpRuntime targetFramework="4.5" />
  </system.web>
  <system.serviceModel>
    <services>
      <service name="WcfSimpleTokenExample.Services.AuthenticationTokenService" behaviorConfiguration="ServiceBehaviorHttp">
        <endpoint address="" behaviorConfiguration="AjaxEnabledBehavior" binding="webHttpBinding" bindingConfiguration="webBindingSSL" contract="WcfSimpleTokenExample.Services.AuthenticationTokenService" />
      </service>
      <service name="WcfSimpleTokenExample.Services.Test1Service" behaviorConfiguration="ServiceRequiresTokenBehaviorHttp">
        <endpoint address="" behaviorConfiguration="AjaxEnabledBehavior" binding="webHttpBinding" bindingConfiguration="webBindingSSL" contract="WcfSimpleTokenExample.Services.Test1Service" />
      </service>
    </services>
    <behaviors>
      <endpointBehaviors>
        <behavior name="AjaxEnabledBehavior">
          <webHttp helpEnabled="true" />
        </behavior>
      </endpointBehaviors>
      <serviceBehaviors>
        <behavior name="ServiceBehaviorHttp">
          <serviceMetadata httpGetEnabled="true" httpsGetEnabled="true" />
          <serviceDebug includeExceptionDetailInFaults="true" />
        </behavior>
        <behavior name="ServiceRequiresTokenBehaviorHttp">
          <serviceMetadata httpGetEnabled="true" httpsGetEnabled="true" />
          <serviceDebug includeExceptionDetailInFaults="true" />
          <TokenValidationBehaviorExtension />
        </behavior>
      </serviceBehaviors>
    </behaviors>
    <extensions>
      <behaviorExtensions>
        <add name="TokenValidationBehaviorExtension"
          type="WcfSimpleTokenExample.Behaviors.TokenValidationBehaviorExtension, WcfSimpleTokenExample, Version=1.0.0.0, Culture=neutral"/>
      </behaviorExtensions>
    </extensions>
    <bindings>
      <webHttpBinding>
        <binding name="webBindingSSL">
          <security mode="Transport">
            <transport clientCredentialType="None"/>
          </security>
        </binding>
      </webHttpBinding>
    </bindings>
    <serviceHostingEnvironment aspNetCompatibilityEnabled="false" multipleSiteBindingsEnabled="true" />
  </system.serviceModel>
  <system.webServer>
    <modules runAllManagedModulesForAllRequests="true" />
    <directoryBrowse enabled="true" />
  </system.webServer>
  <entityFramework>
    <defaultConnectionFactory type="System.Data.Entity.Infrastructure.LocalDbConnectionFactory, EntityFramework">
      <parameters>
        <parameter value="v11.0" />
      </parameters>
    </defaultConnectionFactory>
    <providers>
      <provider invariantName="System.Data.SqlClient" type="System.Data.Entity.SqlServer.SqlProviderServices, EntityFramework.SqlServer" />
    </providers>
  </entityFramework>
  <connectionStrings>
    <add name="BasicTokenDbConnection" connectionString="data source=(LocalDB)\v11.0;attachdbfilename=|DataDirectory|\BasicTokenDatabase.mdf;integrated security=True;MultipleActiveResultSets=True;App=EntityFramework" providerName="System.Data.SqlClient" />
  </connectionStrings>
</configuration>

Configuring the SSL Certificate

An SSL certification was generated for me when I built and ran the project. I was able to choose via a pop-up to trust the certificate.

Go on and check out part 6 here: Basic Token Service for WCF Services (Part 6 – A JavaScript client)

Authentication Token Service for WCF Services (Part 4 – Supporting Basic Authentication)

In Authentication Token Service for WCF Services (Part 3 – Token Validation in IDispatchMessageInspector) we showed how to verify our token against a database. The token is a great tool. The authentication service also provides the token based on a post of credentials.

In this article, we are going to add support for Basic Authentication. We aren’t going to do it the standard WCF way, using Transport security. We will keep our security at none, expect the deployment to be https and roll our own code to handle Basic Authentication.

Download this project here: WCF Basic Auth

There are two features we want in order claim support Basic Authentication.

  1. Allow AuthenticationTokenService.svc to create the token by optionally using Basic Authentication.
  2. Allow Basic Authentication as an option to providing a token.

To provide these two features, first we have to understand Basic Authentication. Basic Authentication is a well-known standard that is defined.

Basic Authentication is an html request header. The header is named “Authorization” and the value is as follows:

Basic amFyZWQ6dGVzdHB3

The first part of the Authorization header value is just the word “Basic” followed by a space.
The second part is the username and password concatenated together with a semicolon separator and then Base64 encoded.

jared:testpw
Basic amFyZWQ6dGVzdHB3

Let’s start with a simple class to manage the Basic authentication header, and encoding and decoding it.

using System;
using System.Text;
using WcfSimpleTokenExample.Model;

namespace WcfSimpleTokenExample.Business
{
    public class BasicAuth
    {
        private readonly string _User;
        private readonly string _Password;
        private const string Prefix = "Basic ";

        #region Constructors
        public BasicAuth(string encodedHeader)
            : this(encodedHeader, Encoding.UTF8)
        {
        }

        public BasicAuth(string encodedHeader, Encoding encoding)
        {
            HeaderValue = encodedHeader;
            var decodedHeader = encodedHeader.StartsWith(Prefix, StringComparison.OrdinalIgnoreCase)
                ? encoding.GetString(Convert.FromBase64String(encodedHeader.Substring(Prefix.Length)))
                : encoding.GetString(Convert.FromBase64String(encodedHeader));
            var credArray = decodedHeader.Split(':');
            if (credArray.Length > 0)
                _User = credArray[0];
            if (credArray.Length > 1)
                _Password = credArray[1];
        }

        public BasicAuth(string user, string password)
            : this(user, password, Encoding.UTF8)
        {
        }

        public BasicAuth(string user, string password, Encoding encoding)
        {
            _User = user;
            _Password = password;
            HeaderValue = Prefix + Convert.ToBase64String(encoding.GetBytes(string.Format("{0}:{1}", _User, _Password)));
        }
        #endregion

        public Credentials Creds
        {
            get { return _Creds ?? (_Creds = new Credentials { User = _User, Password = _Password }); }
        }
        private Credentials _Creds;

        public string HeaderValue { get; }
    }
}

BasicAuth.cs has constructors that allow for encoding by passing in a username and password and encoding it, as well as constructors that allow for passing in the header value and decoding it to get the username and password.

If we add BasicAuth.cs to our existing WcfSimpleTokenExample project, we can easily use it to support Basic Authentication.

Feature 1 – Basic Authentication for AuthenticationTokenService.svc/Authenticate

By using the BasicAuth.cs class, we can provide support for Basic Authentication in our token service using only 3 lines of code. Below is our new AuthenticationTokenService.svc.cs. Lines 18-20 our the new lines we add.

using System.ServiceModel;
using System.ServiceModel.Activation;
using System.ServiceModel.Web;
using WcfSimpleTokenExample.Business;
using WcfSimpleTokenExample.Database;
using WcfSimpleTokenExample.Model;

namespace WcfSimpleTokenExample.Services
{
    [ServiceContract]
    [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
    public class AuthenticationTokenService
    {
        [WebInvoke(Method = "POST", RequestFormat = WebMessageFormat.Json, ResponseFormat = WebMessageFormat.Json, BodyStyle = WebMessageBodyStyle.Bare)]
        [OperationContract]
        public string Authenticate(Credentials creds)
        {
            if (creds == null && WebOperationContext.Current != null)
            {
                creds = new BasicAuth(WebOperationContext.Current.IncomingRequest.Headers["Authorization"]).Creds;
            }
            using (var dbContext = new BasicTokenDbContext())
            {
                return new DatabaseTokenBuilder(dbContext).Build(creds);
            }
        }
    }
}

Feature 2 – Using Basic Authentication instead of a token

In our TokenValidationInspector.cs file, we are already validating the token using DatabaseTokenValidator, Now we need to validate the crendentials. We can validate credentials using the DatabaseCrendentialsValidator object that is already being used by AuthenticationTokenBuilder. However, we have to add some conditionaly code to test if a token is provided or if Basic Authorization is provided. If both are ignored, the token takes priority.

To do this, I wrapped the existing lines calling DatabaseTokenValidator into a method called ValidateToken. THen I created a new method called ValidateBasicAuthentication, which we only attempt to call a token isn’t provided.

using System.Net;
using System.Security.Authentication;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Dispatcher;
using System.ServiceModel.Web;
using WcfSimpleTokenExample.Business;
using WcfSimpleTokenExample.Database;
using WcfSimpleTokenExample.Interfaces;

namespace WcfSimpleTokenExample.Behaviors
{
    public class TokenValidationInspector : IDispatchMessageInspector
    {
        public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
        {
            // Return BadRequest if request is null
            if (WebOperationContext.Current == null) { throw new WebFaultException(HttpStatusCode.BadRequest); }

            // Get Token from header
            var token = WebOperationContext.Current.IncomingRequest.Headers["Token"];
            if (!string.IsNullOrWhiteSpace(token))
            {
                ValidateToken(token);
            }
            else
            {
                ValidateBasicAuthentication();
            }
            return null;
        }
        
        private static void ValidateToken(string token)
        {
            using (var dbContext = new BasicTokenDbContext())
            {
                ITokenValidator validator = new DatabaseTokenValidator(dbContext);
                if (!validator.IsValid(token))
                {
                    throw new WebFaultException(HttpStatusCode.Forbidden);
                }
                // Add User ids to the header so the service has them if needed
                WebOperationContext.Current.IncomingRequest.Headers.Add("User", validator.Token.User.Username);
                WebOperationContext.Current.IncomingRequest.Headers.Add("UserId", validator.Token.User.Id.ToString());
            }
        }


        private static void ValidateBasicAuthentication()
        {
            var authorization = WebOperationContext.Current.IncomingRequest.Headers["Authorization"];
            if (string.IsNullOrWhiteSpace(authorization))
            {
                using (var dbContext = new BasicTokenDbContext())
                {
                    var basicAuth = new BasicAuth(authorization);
                    if (!new DatabaseCredentialsValidator(dbContext).IsValid(basicAuth.Creds))
                    {
                        throw new AuthenticationException();
                    }
                }
            }
        }

        public void BeforeSendReply(ref Message reply, object correlationState)
        {
        }
    }
}

The web.config

There are not changes needed for the web.config. Here is a copy of it though, for reference.

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <configSections>
    <!-- For more information on Entity Framework configuration, visit http://go.microsoft.com/fwlink/?LinkID=237468 -->
    <section name="entityFramework" type="System.Data.Entity.Internal.ConfigFile.EntityFrameworkSection, EntityFramework, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" requirePermission="false" />
  </configSections>
  <appSettings>
    <add key="aspnet:UseTaskFriendlySynchronizationContext" value="true" />
  </appSettings>
  <system.web>
    <compilation debug="true" targetFramework="4.5" />
    <httpRuntime targetFramework="4.5" />
  </system.web>
  <system.serviceModel>
    <services>
      <service name="WcfSimpleTokenExample.Services.AuthenticationTokenService" behaviorConfiguration="ServiceBehaviorHttp">
        <endpoint address="" behaviorConfiguration="AjaxEnabledBehavior" binding="webHttpBinding" contract="WcfSimpleTokenExample.Services.AuthenticationTokenService" />
      </service>
      <service name="WcfSimpleTokenExample.Services.Test1Service" behaviorConfiguration="ServiceRequiresTokenBehaviorHttp">
        <endpoint address="" behaviorConfiguration="AjaxEnabledBehavior" binding="webHttpBinding" contract="WcfSimpleTokenExample.Services.Test1Service" />
      </service>
    </services>
    <behaviors>
      <endpointBehaviors>
        <behavior name="AjaxEnabledBehavior">
          <webHttp helpEnabled="true" />
        </behavior>
      </endpointBehaviors>
      <serviceBehaviors>
        <behavior name="ServiceBehaviorHttp">
          <serviceMetadata httpGetEnabled="true" httpsGetEnabled="true" />
          <serviceDebug includeExceptionDetailInFaults="true" />
        </behavior>
        <behavior name="ServiceRequiresTokenBehaviorHttp">
          <serviceMetadata httpGetEnabled="true" httpsGetEnabled="true" />
          <serviceDebug includeExceptionDetailInFaults="true" />
          <TokenValidationBehaviorExtension />
        </behavior>
      </serviceBehaviors>
    </behaviors>
    <extensions>
      <behaviorExtensions>
        <add name="TokenValidationBehaviorExtension"
          type="WcfSimpleTokenExample.Behaviors.TokenValidationBehaviorExtension, WcfSimpleTokenExample, Version=1.0.0.0, Culture=neutral"/>
      </behaviorExtensions>
    </extensions>
    <serviceHostingEnvironment aspNetCompatibilityEnabled="false" multipleSiteBindingsEnabled="true" />
  </system.serviceModel>
  <system.webServer>
    <modules runAllManagedModulesForAllRequests="true" />
    <directoryBrowse enabled="true" />
  </system.webServer>
  <entityFramework>
    <defaultConnectionFactory type="System.Data.Entity.Infrastructure.LocalDbConnectionFactory, EntityFramework">
      <parameters>
        <parameter value="v11.0" />
      </parameters>
    </defaultConnectionFactory>
    <providers>
      <provider invariantName="System.Data.SqlClient" type="System.Data.Entity.SqlServer.SqlProviderServices, EntityFramework.SqlServer" />
    </providers>
  </entityFramework>
  <connectionStrings>
    <add name="BasicTokenDbConnection" connectionString="data source=(LocalDB)\v11.0;attachdbfilename=|DataDirectory|\BasicTokenDatabase.mdf;integrated security=True;MultipleActiveResultSets=True;App=EntityFramework" providerName="System.Data.SqlClient" />
  </connectionStrings>
</configuration>

Testing Basic Authentication with PostMan

Now we an test that this is working using PostMan. Our PostMan call is similar to what we did in previous articles, but instead of passing a token header, we set Basic Authentication, which sets the Authorization header for us (yes, you could have set the Authorization header manually.)

You could create the Authorization header yourself, but PostMan will create it for you if you click the Authorization and select Basic Auth. Enter your username and password and click update.

PostManBasicAuth

All this does it create an Authorization header for you. You can see this by clicking on the Headers tab in PostMan.

PostManBasicAuthHeader

Go ahead and click Send and you will get your authentication.

Notice the url is https in the image. I haven’t shown you how to do that yet. That is in part 5 here: Authentication Token Service for WCF Services (Part 5 – Adding SSL)