Hidden merging of the entities collections

Merge two collection of the entities?

Sometimes in our applications we have problems with the performance of the operations, that are performed on the collections of the entities. Usually the problem is caused by a lot of joins between tables. If we don't want to build big, time consuming queries that return a lot of data, we can hit database a few more times and join the returned collections.

In this case, when we can get some objects in one hit (using Entity Framework) and after that, take the children (objects connected with the navigation properties) using another query. After that we can merge both collections by setting the correct values of the navigation properties in any of those two collections.

Faster solution

However, if we do both of operations using one ObjectContext in one scope, we do not need to set the navigation properties manually. The Entity Framework will do this for us automatically.

In the example below we pass the collection of the entities without connected navigation properties to the method, then we get the id's (or any other identification fields from the entities) and we take the data from the included table with full product data. In this case we do not need to merge the collections. As a result of this method we will receive the collection of ProductSets with attached products with all the full data included.

Example

        public static void AttachDespatchItemsToDespatchPackages(List<ProductSet> listToWhichWeWantToAttachObjects, 
               ObjectContext ctx)
        {
            List<int> productsSetsIds = listToWhichWeWantToAttachObjects
                .SelectMany(d => d.ProductSets.Select(dp => dp.ProductSetId))
                .Distinct()
                .ToList();
            List<Product> productsForProductSet = new List<Product>();
            if (productsSetsIds.Any())
            {
                productsForProductSet = ctx.Products
                    .Include("FullProductData")
                    .Where(p => productsSetsIds.Contains(p.ProductSetId))
                    .ToList();
            }
        }

Read More

How to set Bootstrap menu active class using ASP.NET MVC ?

Bootstrap framework is currently the most popular framework (or rather a set of themes and controls) which makes creating of the responsive websites very easy. Unfortunately, some effects on the website are not easy to reach in caseyou want to create a ASP.NET MVC web application using the partial views. One of them is setting of the specific style on the Bootstrap navbar "li" active element.

You can obviously achieve the desired style on the active "li" element of the navbar by using a Javascript function which would check what page was loaded by the address (or e.g. the content) and set the class on the element, but it is complicated and not very elegant solution.

The best way, to achieve the mentioned effect is to use the extended MenuLink method on the ASP.NET backend of the application.

Changes on the UI

Firstly, we need to use a MenuLink in the Bootstrap menu. so it would look like more-less like this:

 

            

                @Html.MenuLink("Suppliers", "Index", "Supplier")
                @Html.MenuLink("Customers", "Index", "Customer")
		@Html.MenuLink("Orders", "Index", "Order")
	    
 

In the example I have replaced ActionLinks with Menu links. Without backend changes it won't give us a result, but now we will add an Extension method o the backend.

Changes on the backend

Lets create a new class, which will hold all of the helpers, which may be used on the UI directly. In case of our problem, we will an extension method for the MVC MenuLink. The code of the method is below.

using System.Web.Mvc;
using System.Web.Mvc.Html;
using System.Web.Routing;

public static class HtmlHelpers
{
    //Extensibl method MenuLink
    public static MvcHtmlString MenuLink(this HtmlHelper htmlHelper, string linkText, string actionName, string controllerName)
    {
        //Create a tag, that will be an action link inside a "li" element
        TagBuilder builder = new TagBuilder("li")
        {
            InnerHtml = htmlHelper.ActionLink(linkText, actionName, controllerName).ToHtmlString()
        };
        //Get current routes from the context of the view.
        RouteData route = htmlHelper.ViewContext.RouteData;
        //Gets the controller and the action from the route data
        string action = route.GetRequiredString("action");
        string controller = route.GetRequiredString("controller");
        //If the current controller and action are the same as the element on the navbar menu,
        //then we need to add the class "active" on the tag.
        if (controllerName == controller && actionName == action)
        {
            builder.AddCssClass("active");
        }
        return new MvcHtmlString(builder.ToString());
    }
}

This simple and elegant solution will make application niecer and the management will be much easier. You won't need to touch the mechanism of setting of the Bootstrap active classes any more.

Read More

How to generate a WCF service from the WSDL file?

Why we need to generate WCF service using WSDL?

Usually we create our own webservices, but sometimes we need to create a mock of the webservice from which WSDL we have obtained. This situation may happen if we have to create a client of the third-party service to which the access is restricted. In that case it is easier to create our own service, than use the real one. It is especially useful when we shoot the data to the service and we do not really need the response except possible exceptions.

How to do it?

Firstly we need to have w WSDL file which will be a base for our mock. Then we need to generate the interface, which will be a contract in our new service. To do this, we need to use small application called wsdl.exe. It is a part of the Windows SDK and it can be found e.g. here: C:\Program Files (x86)\Microsoft SDKs\Windows\v8.1A\bin\NETFX 4.5.1 Tools>wsdl.exe. To generate the interface in C#, you should use the following command:

C:\Program Files (x86)\Microsoft SDKs\Windows\v8.1A\bin\NETFX 4.5.1 Tools>wsdl.exe "C:\WsdlToGenerateInterfaceFrom.wsdl" /l:CS /serverInterface

After execution of this command, the interface will be generated in a folder, where the wsdl.exe is placed. Sometimes there may be some warnings like:

Warning: This web reference does not conform to WS-I Basic Profile v1.1.
R2706: A wsdl:binding in a DESCRIPTION MUST use the value of "literal" for the use attribute in all soapbind:body, soapbind:fault, soapbind:header and soapbind: headerfault elements.

Hopefully, usually the warnings are not danger. Now you can create new VS WCF library (service) project and implement the interface (your contract).

After implementing of the interface it is good to run the web service and look into the WSDL file generated by it. Unfortunately sometimes, some of the types may be missing. It happens due to the fact, that there are some attributes added automatically to the generated classes. We need to be aware that some of them may be removed or sometimes, we need to add some attributes (like DataContract or OperationContract)

Finally we can use our webservice as a mock for other applications. This is very useful for quick tests of some behaviors.

Read More

"HasValue vs null-check" and "Boxing vs Value property"

A few days ago I took part in a discussion about the differences in performance of the popular expressions, that every developer uses almost every day in the code. The subjects of the discussion were the difference between: null checking versus the HasValue property and boxing cast versus Value property. I have never checked what are the differences between them on my own. I heard a lot of gossips about those expressions and so I have decided to look into the structure of the compiled code. To test the compiled code I have used "IL Disassembler" - the tool, which is included in the Visual Studio package. Here are the results of my investigation.

Boxing vs Value property

Firstly, I created a simple console application, which assigned nullabale integer to two different variables. In the first case, the value was boxed and in the second one, I used the Value property. The code of the application is below:

namespace NullableTest
{
    class Program
    {
        static void Main(string[] args)
        {
            int? testInt = 0;
            int castValue = (int) testInt;
            int valueProperty = testInt.Value;
        }
    }
}

Next, I have started IL Disassembler and looked into the application assembly. The result was a little bit surprising:

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // Code size       25 (0x19)
  .maxstack  2
  .locals init ([0] valuetype [mscorlib]System.Nullable`1 testInt)
  IL_0000:  ldloca.s   testInt
  IL_0002:  ldc.i4.0
  IL_0003:  call       instance void valuetype [mscorlib]System.Nullable`1::.ctor(!0)
  IL_0008:  ldloca.s   testInt
  IL_000a:  call       instance !0 valuetype [mscorlib]System.Nullable`1::get_Value()
  IL_000f:  pop
  IL_0010:  ldloca.s   testInt
  IL_0012:  call       instance !0 valuetype [mscorlib]System.Nullable`1::get_Value()
  IL_0017:  pop
  IL_0018:  ret
} // end of method Program::Main

It occurred, that both constructions are replaced by the body of the Value() property. It means that the performance is exactly the same. There are no differences in the execution time of both structures. You can choose the one you prefer.

HasValue vs null-check

As a next step, I have created another console application, which was checking if the nullable variable is a null. I made it in two different ways: by using the classic null-check and then by using the HasValue property. Here is the code of the application:

namespace NullableTest
{
    class Program
    {
        static void Main(string[] args)
        {
            int? testInt = 0;
            if (testInt != null)
            {
                //Do something ...
            }
            if (testInt.HasValue)
            {
                //Do something else ...
            }
        }
    }
}

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // Code size       25 (0x19)
  .maxstack  2
  .locals init ([0] valuetype [mscorlib]System.Nullable`1 testInt)
  IL_0000:  ldloca.s   testInt
  IL_0002:  ldc.i4.0
  IL_0003:  call       instance void valuetype [mscorlib]System.Nullable`1::.ctor(!0)
  IL_0008:  ldloca.s   testInt
  IL_000a:  call       instance bool valuetype [mscorlib]System.Nullable`1::get_HasValue()
  IL_000f:  pop
  IL_0010:  ldloca.s   testInt
  IL_0012:  call       instance bool valuetype [mscorlib]System.Nullable`1::get_HasValue()
  IL_0017:  pop
  IL_0018:  ret
} // end of method Program::Main

And another surprise! Both constructions are replaced by the body of the HasValue property. Once again it means that the performance is exactly the same and you can choose the one you prefer.

Honestly, I was surprised by the results of the investigation and I can say only one thing: if we are not sure how the code will look after compilation, let's check it using disassebler. After that we will be able to tell exactly what code is a real result of our work and there won't be any discussions about performance... at least in those two cases :)

Read More

How to get database column property for entity?

Why getting the column property for the entity is a problem?

When we use Entity Framework, we often want to get some information about some columns, that are a part of the database table, which is behind the entity. The most elegant way of getting this information is to use a partial class which contains the decorated (with attributes) properties. It may look like below:

[Column("Description")]
[Required(ErrorMessage = "Description is mandatory!")]
[StringLength(255, MinimumLength = 5, ErrorMessage = "The description must contain more than 5 and less then 255 characters!")]
public string Description{ get; set; }

This solution is the most elegant and easiest to use. You can use e.g. the messages in the higher layers of your application and use the lenght in validation of the objects also on the higher layers of the application. Unfortunatly, it is hard to use this mechanism in the application that has a big database and you have very limited time to make a change.

Quick solution

If you have the problem as stated above, you can use a little bit different solution - get access to the properties by the Reflection. The main idea is to access the properties of the entity by its names and types represented as strings like below:

        public static object GetInfoAboutColumn<TypeOfEntity>(ObjectContext objectContext, 
                              Expression<Func<TypeOfEntity, string>> column, 
                              string typeName, 
                              string propertyName)
        {
            object resultValue = null;
            Type entType = typeof(TypeOfEntity); //we need to know the type of the entity, so we know what we should look for
            string columnName = ((MemberExpression)column.Body).Member.Name; //Get the name of the column (field) in entity
            if (objectContext != null)
            {
               // Get collection of items from the context.
               ReadOnlyCollection<GlobalItem> globalItems = objectContext.MetadataWorkspace.GetItems(DataSpace.CSpace);
               if (globalItems != null)
               {
                 // Get properties of the given type and name from the given entity.
                 var allPropertiesOfType = 
                                 GetAllPropertiesOfType<TypeOfEntity>(typeName, globalItems, columnName, entType);
                 IEnumerable<object> propertyResults = 
                                 allPropertiesOfType.Select(sel => sel.TypeUsage.Facets[propertyName].Value).ToList();
                 if (propertyResults.Any())
                 {
                     resultValue = propertyResults.First(); // Get the value which we were looking for.
                 }
               }
            }
            return resultValue;
        }

The most interesting of this solution is the mechanism of looking for the value, that we are interested in the collection of the entities. It can be done by the LINQ query as below:

        private static IEnumerable<EdmProperty> GetAllPropertiesOfType<TypeOfEntity>(string typeName, 
                                                     ReadOnlyCollection<GlobalItem> globalItems, 
                                                     string columnName, 
                                                     Type entType)
        {
            IEnumerable<EdmProperty> allPropertiesOfType = globalItems
                .Where(m => m.BuiltInTypeKind == BuiltInTypeKind.EntityType)
                .SelectMany(meta => ((EntityType) meta)
                    .Properties
                    .Where(p => p.Name == columnName
                                && p.TypeUsage.EdmType.Name == typeName
                                && p.DeclaringType.Name == entType.Name));
            return allPropertiesOfType;
        }

You can test it for example by trying to get "MaxLength" property of any entity. Cheers!

Read More

How to replace "switch" with the polymorphism?

Problem

A few days ago we were discussing the coding standards, that we are going to adhere. One of the points was preventing from creating of the very big conditional statements.

Lets take the "switch" statement into consideration. It is nothing wrong in using this statement until it does one thing, but as we all know, "switch" usually makes a lot of things and it is much bigger, then it should be. If we want to adhere SOLID principles, we cannot write huge, multi-actions conditional statements.

In this post I want to show you one of the most popular methods of replacing of the "switch" with the polymorphism. Lets see how to do this?

Solution

public class DocumentsHandler
{
    public void HandleDocument(Document document)
    {
        //...
        List importedDocumentElementsIds = GetImportedDocumentElementsIds(clientName, document);
        //...
    }

    public List GetImportedDocumentElementsIds(string clientName, object document)
    {
        /* Somewhere in the code we have:
         * - entity context
         * - name of the client
         * 
         * Some operations ...
         * 
         * */
        switch typeof(document)
        {
            case Sales :
                return BaseDocumentElementsImport(clientName, context.GetSalesDocumentsElements())
            case Purchase :
                return BaseDocumentElementsImport(clientName, context.GetPurchaseDocumentsElements())
            case Custom :
                return BaseDocumentElementsImport(clientName, context.GetCustomDocumentsElements())
            // other document types...
            case default :
                return BaseDocumentElementsImport(clientName, context.GetOtherDocumentsElements())
        }
    }
}

Now we will replace an old Document with a new one. It will be an abstract class with an template method, which we are going to override.

public abstract class Document
{
    public abstract List ImportDocumentElements(string clientName)
}

In the next step we create a set of derived classes which will contain overriden template method.

    public class SalesDocument : Document
    {
        //...
          public override List ImportDocumentElements(string clientName) 
          {
            return BaseDocumentElementsImport(clientName, context.GetSalesDocumentsElements());
          } 
        //...
    }

    public class PurchaseDocument : Document
    {
        //...
          public override List ImportDocumentElements(string clientName) 
          {
            return BaseDocumentElementsImport(clientName, context.GetPurchaseDocumentsElements());
          } 
        //...
    }

    public class CustomDocument : Document
    {
        //...
          public override List ImportDocumentElements(string clientName) 
          {
            return BaseDocumentElementsImport(clientName, context.GetCustomDocumentsElements());
          } 
        //...
    }

    public class OtherDocument : Document
    {
        //...
          public override List ImportDocumentElements(string clientName) 
          {
            return BaseDocumentElementsImport(clientName, context.GetOtherDocumentsElements());
          } 
        //...
    }

Now in the code we can write simple, short line of code like below:

List importedDocumentElementsIds = document.ImportDocumentElements(clientName));

Benefits

It seems that the code is now more complicated and we wrote more LOCs, so why did we do this?

• We do not duplicate the code because we do not have identical conditions.
• Usage is simpler and more elegant, because we write smaller numer of LOCs.
• Object knows everything about itself. We do not need to pass the state the the object under some conditions. We only need to tell the object to perform the operation and it will decide how to do this.
• Now our code is extensible. We can add new class with new implementation of the overriden method instead of adding new case to the "switch". To be honest, "switch" conditions like to grow very quickly.

Read More

ForEach != foreach

It is very often that we have to make some operations on every element in the collection. The most popular ways of doing this is to use a “for” or ”foreach” loop. Here are three ways of doing this:

• “For” loop – One of the oldest loops known to the mankind. It is the easy solution to get e.g. particular element of the array, but it is not the most efficient way of iterating over collections.
• “foreach” loop – This is a newer type of loop which iterates over the whole collection of objects. It is easy, it is fast and you can use it on every ICollection and array.
• "ForEach" – Public method of the generic list which, from the definition: Performs the specified action on each element of the System.Collections.Generic.List. This is considered as the fastest way of doing some operations on every element of the generic List.

At first it seems that the classic “foreach” and generic List “ForEach” are the same, there are some significant differences. Here is a very simple example of them suing the most popular collection: generic list.

Let’s create a list of strings and populate it with come Guids:

List listOfStrings = new List();
            
            for (int i = 0; i < 1000000; i++)
            {
              listOfStrings.Add(Guid.NewGuid().ToString());  
            }

Now initialize a new list which will be holding changed values from our first list:

List listOfNewStrings = new List();

And now we will do some operations on each element of the collection using classic foreach:

foreach (string s in listOfStrings)
            {
                if (s.Contains("6"))
                    continue;
                else if (s.Contains("4"))
                    return;
                else
                    listOfNewStrings.Add(string.Format(s + "{0}", "SUFIX"));
            }

Everything is ok, the code is compiling and now we will do the funny part. We will make some operations on every element of the list using the generic list ForEach method:

listOfStrings.ForEach(s => 
                {
                    if (s.Contains("6"))
                        continue;
                    else if (s.Contains("4"))
                        return;
                    else
                        listOfNewStrings.Add(string.Format(s + "{0}", "SUFIX"));
                });

And here is the surprise- the code is not compiling. We do the same operations on the same list so what is going on?

The answer is quite simple: ForEach from the System.Collections.Generic.List is not a loop, but a normal method. As it is not a loop, then we cannot break it or continue.

ForEach, as an argument, takes the System.Action delegate. This action will be performed on each element of the list. In other words: we do some operations on each element of the list, but we cannot “break” the execution or “continue” the execution, we can only exit ForEach using return. Remember that ForEach is a function, so we return only from the ForEach and pass the control to the function, that started ForEach execution and in case of “foreach” loop – return will finish execution of the whole function.

The advantages of using “ForEach” are the ease of use, readability and ForEach can modify the list over which it is iterating, so if we do not need to use break or continue inside the loop, we can use the ForEach on the generic List.

Read More

Unit testing with authentication

When we are developing an application that will be integrating with third party system, we often face the problem of testing some methods, that are using common session, which ID is being returned to us as a result of Authentication process. I have met this problem many times, when I was making integration with ERP systems, WMS's and lately, with eCommerce. I was wondering: how the hell I can write the tests of many methods, using the same session, and make them independent?

I have found some ideas on the blogs and in the articles:

• Some developers were advising to create one huge test with many assertions, which will start with Login (Authenticate, LogOn, StartSession etc.) method and end with Logout (CloseSession, LogOff, etc). This idea is OK, but it is NOT a UNIT test.
• Other developers were advising to use some unit testing libraries that enable passing the state between test methods. This idea is also OK, but this is the way of creating integration tests, not the unit tests!
• The last idea was to log in before and log out after every operation in each unit test. This will also work, but you have to repeat a lot of code, which is a very bad habit.

Finally I have found a solution: IUseFixture interface in xUnit. The framework is very easy to use and unit testing of e.g. API of third party web services is very easy. Here is an example...

Imagine, you want to run some methods of a WS*, which is an API for the ERP system. You want to take some data from the WS*, but you need to be logged in and have a session id. The best way to do this is to use IUseFixture interface.
It is a generic interface, which bases on type, that must by disposable. For example if you want to create session before running each test method and close it after running of each method, you can create your base type like this:

using ThirdPartySystemTests.Service;
using System;

namespace ThirdPartySystemTests
{
    public class SessionFixture : IDisposable
    {
        private SessionHelper sessionHelper;

        public SessionHelper LogOnUser()
        {
          sessionHelper = new SessionHelper();
          sessionHelper.Client = new ThirdPartySystemClient();
          sessionHelper.SessionId = sessionHelper.Client.login
                                   (
                                    sessionHelper.LOGIN, 
                                    sessionHelper.PASSWORD
                                    );
            return sessionHelper;
        }

        public void Dispose()
        {
            bool sessionClosed = 
              sessionHelper.Client.endSession(sessionHelper.SessionId);
        }
    }

    public class SessionHelper
    {
        public ThirdPartySystemClient Client { get; set; }
        public string SessionId { get; set; }
        public string LOGIN = "User";
        public string PASSWORD = "Password";
    }
}

This disposable type has 2 methods: first method creates session on the ThirdPartySystem and the second one closes this session on disposal of the SessionFixture object.
Now it is time to implement tests of ThirdPartySystem using xUnit test with our SessionFixture.

using ThirdPartySystemTests.Service;
using System;
using Xunit;

namespace ThirdPartySystemTests
{
    public class Tests : IUseFixture
    {
        private SessionHelper sessionHelper;

        public void SetFixture(SessionFixture sessionFixture)
        {
            sessionHelper = sessionFixture.LogOnUser();
        }

        [Fact]
        private void GetProductsListTest()
        {
            Product[] products = 
               sessionHelper.Client.GetProductList(sessionHelper.SessionId);
            Assert.NotEmpty(products);
        }

        [Fact]
        private void GetCustomersListTest()
        {
            Customer[] customers = 
               sessionHelper.Client.GetCustomersList(sessionHelper.SessionId);
            Assert.NotEmpty(customers);
        }

        [Fact]
        private void CreateProductTest()
        {
            Prodcut product = new Product
            {
                Name = "Laptop",
                Price = 1000,
                Quantity = 20
            };
            int productId = 
                 sessionHelper.Client.CreateProduct(sessionHelper.SessionId, product);
            Assert.True(productId > 0);
        }
    }
}

Now the LogOnUser method will run before each execution of every test in the class, that implements IUseFixture so you have a new session every time the test runs. What is more, on disposal of the IUseFixture (it means at the end of execution of the test) the session will be closed.

As a result, you have a independent set of unit tests, which do not have any connections and can be run separately. This solution is elegant, easy, safe and it observes the principles of unit tests.

You can also use IUseFixture to e.g. run methods from the base types, create configuration of some objects in the database, prepare data for further operations etc.

Read More