Automapper: Mapping objects Part 5 of 7 (CustomResolver)

Taswar Bhatti March 11, 2011 2 Comments

In Part 5, we will use a powerful feature that automapper allows us, which is CustomResolver.

Lets look at our Domain Object which contains a boolean field called ShipToHomeAddress, what we will do is map those boolean to a string value with “Yes” or “No”.

 public class Order
    {
        public string OrderNo { get; set; }
        public Customer Customer { get; set;  }
        public DateTime PurchaseDate { get; set; }
        public IEnumerable<OrderItems> LineItems { get; set; }
        public bool ShipToHomeAddress { get; set; }
        public decimal GetTotal()
        {
            return LineItems == null ? 0 : LineItems.Sum(x => x.GetTotalPrice());
        }
        public Guid InternalId { get; set; }
    }

//DTO
public class OrderShipDto
    {
        public string ShipHome { get; set; }
        public string CustomerName { get; set; }
    }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

public class Order

{

public string OrderNo { get; set; }

public Customer Customer { get; set; }

public DateTime PurchaseDate { get; set; }

public IEnumerable<OrderItems> LineItems { get; set; }

public bool ShipToHomeAddress { get; set; }

public decimal GetTotal()

{

return LineItems == null ? 0 : LineItems.Sum(x => x.GetTotalPrice());

}

public Guid InternalId { get; set; }

}

//DTO

public class OrderShipDto

{

public string ShipHome { get; set; }

public string CustomerName { get; set; }

}

For our mapping code we will introduce CustomResolver class which inherits from ValueResolver and would map the boolean field to string

 public class CustomBoolResolver: ValueResolver<Order, string>
    {
        protected override string ResolveCore(Order source)
        {
            return source.ShipToHomeAddress ? "Yes" : "No";
        }
    }

1

2

3

4

5

6

7

public class CustomBoolResolver: ValueResolver<Order, string>

{

protected override string ResolveCore(Order source)

{

return source.ShipToHomeAddress ? "Yes" : "No";

}

Now our mapping code would look like

 public ActionResult OrderShip()
        {
            var orders = _respository.GetAll();

            Mapper.CreateMap<Order, OrderShipDto>()
                .ForMember(dest => dest.ShipHome, opt => opt.ResolveUsing<CustomBoolResolver>());

            var model = Mapper.Map<IEnumerable<Order>, IEnumerable<OrderShipDto>>(orders);

            return View(model);
        }

//View
<h2>OrderShip</h2>
<table>
    <tr>        
        <th>Name</th>
        <th>Ship to Home</th>
    </tr>
@foreach (var item in Model)
{
    <tr>       
        <td>@item.CustomerName</td>
        <td>@item.ShipHome</td>
    </tr>
}
 
</table>

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

public ActionResult OrderShip()

{

var orders = _respository.GetAll();

Mapper.CreateMap<Order, OrderShipDto>()

.ForMember(dest => dest.ShipHome, opt => opt.ResolveUsing<CustomBoolResolver>());

var model = Mapper.Map<IEnumerable<Order>, IEnumerable<OrderShipDto>>(orders);

return View(model);

}

//View

<h2>OrderShip</h2>

<table>

<tr>

</tr>

@foreach (var item in Model)

{

<tr>

<td>@item.CustomerName</td>

<td>@item.ShipHome</td>

</tr>

}

</table>

The end result of the view looks like

In Part6, I will show how to use a CustomerFormatter with a Resolver to format the data in a certain way.

Previous Post:
Part 1 (NullSubsitution)
Part 2 (Flattening by Convention)
Part 3 (Nested Mapping)
Part 4 (Projection)

.NET, Automapper

automapper, C#, object mapping

Automapper: Mapping objects Part 4 of 7 (Projection)

Taswar Bhatti March 10, 2011 4 Comments

In Part 4 we will see how we can use projection to map inner objects for example a DateTime field.

Again our domain and Dto (Data Transfer Object) looks like

//Order
 public class Order
 {
        public string OrderNo { get; set; }
        public Customer Customer { get; set;  }
        public DateTime PurchaseDate { get; set; }
        public IEnumerable<OrderItems> LineItems { get; set; }
        public bool ShipToHomeAddress { get; set; }
        public decimal GetTotal()
        {
            return LineItems == null ? 0 : LineItems.Sum(x => x.GetTotalPrice());
        }
        public Guid InternalId { get; set; }
 }

//Dto
 public class OrderDateDto
 {        
        public int PurchaseHour { get; set; }
        public int PurchaseMinute { get; set; }
        public string CustomerName { get; set; }     
 }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

//Order

public class Order

{

public string OrderNo { get; set; }

public Customer Customer { get; set; }

public DateTime PurchaseDate { get; set; }

public IEnumerable<OrderItems> LineItems { get; set; }

public bool ShipToHomeAddress { get; set; }

public decimal GetTotal()

{

return LineItems == null ? 0 : LineItems.Sum(x => x.GetTotalPrice());

}

public Guid InternalId { get; set; }

}

//Dto

public class OrderDateDto

{

public int PurchaseHour { get; set; }

public int PurchaseMinute { get; set; }

public string CustomerName { get; set; }

}

We will map the PurchaseDate in the Domain Object to our Dto PurchaseHour and Purchase Minute.

 public ActionResult OrderDate()
 {
            var order = _respository.Get(3);

            order.PurchaseDate = new DateTime(2011, 3, 15, 20, 30, 0);
            Mapper.CreateMap<Order, OrderDateDto>()
             .ForMember(dest => dest.PurchaseHour, opt => opt.MapFrom(src => src.PurchaseDate.Hour))
             .ForMember(dest => dest.PurchaseMinute, opt => opt.MapFrom(src => src.PurchaseDate.Minute));
            
            var model = Mapper.Map<Order, OrderDateDto>(order);                

            return View(model);
}
//View
<h2>OrderDate</h2>

@Model.CustomerName @Model.PurchaseHour @Model.PurchaseMinute

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

public ActionResult OrderDate()

{

var order = _respository.Get(3);

order.PurchaseDate = new DateTime(2011, 3, 15, 20, 30, 0);

Mapper.CreateMap<Order, OrderDateDto>()

.ForMember(dest => dest.PurchaseHour, opt => opt.MapFrom(src => src.PurchaseDate.Hour))

.ForMember(dest => dest.PurchaseMinute, opt => opt.MapFrom(src => src.PurchaseDate.Minute));

var model = Mapper.Map<Order, OrderDateDto>(order);

return View(model);

}

//View

<h2>OrderDate</h2>

@Model.CustomerName @Model.PurchaseHour @Model.PurchaseMinute

As you can see the View now contains the flatten Hour and Minute, from our previous posting we also see that the other way of nested projection/flattening is by CustomerName.

Here is how our view would display

In part 5, I will show how to use CustomerResolver to resolve and map values to different types.

Previous Post:
Part 1 (NullSubsitution)
Part 2 (Flattening by Convention)
Part 3 (Nested Mapping)

.NET, Automapper

automapper, C#, object mapping

Automapper: Mapping objects Part 3 of 7 (Nested Mapping)

Taswar Bhatti March 9, 2011 11 Comments

In this part we learn about Nested Mapping in Automapper and we will use the same OrderDto Object that we had previously but we will let Automapper to map the inner objects.

Once again here is the Domain Objects First

//Order 
public class Order
    {
        public string OrderNo { get; set; }
        public Customer Customer { get; set;  }
        public DateTime PurchaseDate { get; set; }
        public IEnumerable<OrderItems> LineItems { get; set; }
        public bool ShipToHomeAddress { get; set; }
        public decimal GetTotal()
        {
            return LineItems == null ? 0 : LineItems.Sum(x => x.GetTotalPrice());
        }
        public Guid InternalId { get; set; }
    }

//OrderItems
public class OrderItems
    {
        public decimal Price { get; set; }
        public string Name { get; set; }
        public int Quantity { get; set; }
        public decimal GetTotalPrice()
        {
            return Price * Quantity;
        }
    }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

//Order

public class Order

{

public string OrderNo { get; set; }

public Customer Customer { get; set; }

public DateTime PurchaseDate { get; set; }

public IEnumerable<OrderItems> LineItems { get; set; }

public bool ShipToHomeAddress { get; set; }

public decimal GetTotal()

{

return LineItems == null ? 0 : LineItems.Sum(x => x.GetTotalPrice());

}

public Guid InternalId { get; set; }

}

//OrderItems

public class OrderItems

{

public decimal Price { get; set; }

public string Name { get; set; }

public int Quantity { get; set; }

public decimal GetTotalPrice()

{

return Price * Quantity;

}

The Dto (Data Transfer Object) look like

public class OrderDto
    {
        public string CustomerName { get; set; }
        public decimal Total { get; set; }
        public string OrderNumber { get; set; }
        public IEnumerable<OrderItemsDto> LineItems { get; set; }
    }

//OrderItemsDto
public class OrderItemsDto
    {
        public string Name { get; set; }
        public int Quantity { get; set; }
        public decimal Price { get; set; }
    }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

public class OrderDto

{

public string CustomerName { get; set; }

public decimal Total { get; set; }

public string OrderNumber { get; set; }

public IEnumerable<OrderItemsDto> LineItems { get; set; }

}

//OrderItemsDto

public class OrderItemsDto

{

public string Name { get; set; }

public int Quantity { get; set; }

public decimal Price { get; set; }

}

This time when we map Order to OrderDto we will also provide the mapping of OrderItems to OrderItemsDto.

public ActionResult OrderItems()
        {
            var orders = _respository.GetAll();

            Mapper.CreateMap<Order, OrderDto>()
                .ForMember(dest => dest.OrderNumber, opt => opt.MapFrom(src => src.OrderNo));
                
            Mapper.CreateMap<OrderItems, OrderItemsDto>();

            var model = Mapper.Map<IEnumerable<Order>, IEnumerable<OrderDto>>(orders);

            return View(model);
        }
//View
<table>
    <tr>
        <th>Order Number</th>
        <th>Name</th>
        <th>Total</th>
        <th>Items</th>
    </tr>
@foreach (var item in Model)
{
    <tr>
        <td>@item.OrderNumber</td>
        <td>@item.CustomerName</td>
        <td>$@item.Total</td>
        <td>            
            @foreach (var child in item.LineItems)
            {
                @string.Format("({0}) {1} - ${2}", @child.Quantity, @child.Name, @child.Price)<br />
            }           
       </td>
    </tr>
}
 
</table>

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

public ActionResult OrderItems()

{

var orders = _respository.GetAll();

Mapper.CreateMap<Order, OrderDto>()

.ForMember(dest => dest.OrderNumber, opt => opt.MapFrom(src => src.OrderNo));

Mapper.CreateMap<OrderItems, OrderItemsDto>();

var model = Mapper.Map<IEnumerable<Order>, IEnumerable<OrderDto>>(orders);

return View(model);

}

//View

<table>

<tr>

<th>Order Number</th>

<th>Total</th>

<th>Items</th>

</tr>

@foreach (var item in Model)

{

<tr>

<td>@item.OrderNumber</td>

<td>@item.CustomerName</td>

<td>$@item.Total</td>

<td>

@foreach (var child in item.LineItems)

{

@string.Format("({0}) {1} - ${2}", @child.Quantity, @child.Name, @child.Price)<br />

}

</td>

</tr>

}

</table>

As you can see I have taught automapper about its inner child/object mapping before calling Map, thus it knows about the inner mapping, our result would show like

In the next part I will be showing projection in Automapper.

Previous Post:
Part 1 NullSubsitution
Part 2 Flattening by Convention

.NET, Automapper

automapper, C#, object mapping

Automapper: Mapping objects Part 2 of 7 (Flattening by Convention)

Taswar Bhatti March 8, 2011 2 Comments

In this part I will be showing how Automapper uses flattening by convention.

If we look at our OrderDto we will see that it has a IEnumerable of OrderItemsDto and also something called OrderNumber. This is the type of object we want to send to our presentation layer.

 public class OrderDto
    {
        public string CustomerName { get; set; }
        public decimal Total { get; set; }
        public string OrderNumber { get; set; }
        public IEnumerable<OrderItemsDto> LineItems { get; set; }
    }

1

2

3

4

5

6

7

public class OrderDto

{

public string CustomerName { get; set; }

public decimal Total { get; set; }

public string OrderNumber { get; set; }

public IEnumerable<OrderItemsDto> LineItems { get; set; }

}

Compare that to our domain object where it has a GetTotal method, OrderNo and a Customer Object

//Domain Object
public class Order
    {
        public string OrderNo { get; set; }
        public Customer Customer { get; set;  }
        public DateTime PurchaseDate { get; set; }
        public IEnumerable<OrderItems> LineItems { get; set; }
        public bool ShipToHomeAddress { get; set; }
        public decimal GetTotal()
        {
            return LineItems == null ? 0 : LineItems.Sum(x => x.GetTotalPrice());
        }
        public Guid InternalId { get; set; }
    }

//Customer Domain Object
 public class Customer
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string Bio { get; set; }
        public string GetName()
        {
            return FirstName + ' ' + LastName;
        }       
    }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

//Domain Object

public class Order

{

public string OrderNo { get; set; }

public Customer Customer { get; set; }

public DateTime PurchaseDate { get; set; }

public IEnumerable<OrderItems> LineItems { get; set; }

public bool ShipToHomeAddress { get; set; }

public decimal GetTotal()

{

return LineItems == null ? 0 : LineItems.Sum(x => x.GetTotalPrice());

}

public Guid InternalId { get; set; }

}

//Customer Domain Object

public class Customer

{

public string FirstName { get; set; }

public string LastName { get; set; }

public string Bio { get; set; }

public string GetName()

{

return FirstName + ' ' + LastName;

}

In Automapper there is a convention where it sees the method has a Get in front it. It will then auto flatten it by convention. See how in the OrderDto I have Total as a property and also CustomerName.

Our mapping code would look something like this where we are mapping OrderNo to OrderNumber

 public ActionResult Index()
        {
            var orders = _respository.GetAll();

            AutoMapper.Mapper.CreateMap<Order, OrderDto>()
                .ForMember(dest => dest.OrderNumber, opt => opt.MapFrom(src => src.OrderNo))
                .ForMember(dest => dest.OrderItemsDto, opt => opt.Ignore());

            var model = AutoMapper.Mapper.Map<IEnumerable<Order>, IEnumerable<OrderDto>>(orders);

            return View(model);
        }
//Razor View Code
<h2>Orders</h2>
<table>
    <tr>
        <th>Order Number</th>
        <th>Name</th>
        <th>Total</th>
    </tr>
@foreach (var item in Model)
{
    <tr>
        <td>@item.OrderNumber</td>
        <td>@item.CustomerName</td>
        <td>$@item.Total</td>
    </tr>
}
</table>

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

public ActionResult Index()

{

var orders = _respository.GetAll();

AutoMapper.Mapper.CreateMap<Order, OrderDto>()

.ForMember(dest => dest.OrderNumber, opt => opt.MapFrom(src => src.OrderNo))

.ForMember(dest => dest.OrderItemsDto, opt => opt.Ignore());

var model = AutoMapper.Mapper.Map<IEnumerable<Order>, IEnumerable<OrderDto>>(orders);

return View(model);

}

//Razor View Code

<h2>Orders</h2>

<table>

<tr>

<th>Order Number</th>

<th>Total</th>

</tr>

@foreach (var item in Model)

{

<tr>

<td>@item.OrderNumber</td>

<td>@item.CustomerName</td>

<td>$@item.Total</td>

</tr>

}

</table>

With this mapping will not get the inner mapping of OrderItems since we have told Automapper to Ignore those guys don’t map the OrderItems, as it stands OrderItemsDto would be null

This would produce a view looking like

As you can see Automapper automatically has pulled out GetTotal and populated Total Property and so is Customer object with GetName method with CustomerName. By using these simple conventions it automatically does the work for you without explicitly specifying it.

In next part we will talk about Nested mapping.

Previous Post:
Part 1 Null Subsitution

.NET, Automapper

automapper, C#, object mapping

Automapper: Mapping objects Part 1 of 7 (NullSubstitution)

Taswar Bhatti March 7, 2011 2 Comments

Recently I gave a talk on Automapper in Ottawa .Net Community, so I though I would post the main ideas of the presentation here also.

The demo was based on an Order System where there were just 3 tables/classes, “Order”, “Customer” and “OrderItems”

From the diagram we can see that a Customer has a Bio and if we pull out all the customer from a repository and display it, we may have some of them whom are missing the Bio.

Here is the code of how we are mapping our domain objects to a Dto or ViewModel, we are basically just passing the data to the View to render

//customer dto
public class CustomerDto
    {
        public string Bio { get; set; }
        public string Name { get; set; }
    }

//Controller
public ActionResult Index()
        {
            var customers = _respository.GetAll();

            AutoMapper.Mapper.CreateMap<Customer, CustomerDto>();          
            var model = AutoMapper.Mapper.Map<IEnumerable<Customer>, IEnumerable<CustomerDto>>(customers);
                       
            return View(model);
        }

//View
<h2>Customers</h2>

@foreach (var customer in Model)
{
    <p>
    @("Name : " + customer.Name) <br /> 
    @("Bio : " + customer.Bio) <br />
    </p> 
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

//customer dto

public class CustomerDto

{

public string Bio { get; set; }

public string Name { get; set; }

}

//Controller

public ActionResult Index()

{

var customers = _respository.GetAll();

AutoMapper.Mapper.CreateMap<Customer, CustomerDto>();

var model = AutoMapper.Mapper.Map<IEnumerable<Customer>, IEnumerable<CustomerDto>>(customers);

return View(model);

}

//View

<h2>Customers</h2>

@foreach (var customer in Model)

{

<p>

@("Name : " + customer.Name) <br />

@("Bio : " + customer.Bio) <br />

</p>

}

Now lets say you want to replace the Null Bio with something like “N/A”, some people may go directly to the razor view code and add that but we can do better with automapper, we can tell automapper that when there is a Null just substitute (i.e NullSubsitution) it with something else, our code would then look like

 public ActionResult Index()
        {
            var customers = _respository.GetAll();

            AutoMapper.Mapper.CreateMap<Customer, CustomerDto>()
                .ForMember(dest => dest.Bio, opt => opt.NullSubstitute("N/A"));
            var model = AutoMapper.Mapper.Map<IEnumerable<Customer>, IEnumerable<CustomerDto>>(customers);
                       
            return View(model);
        }

1

2

3

4

5

6

7

8

9

10

public ActionResult Index()

{

var customers = _respository.GetAll();

AutoMapper.Mapper.CreateMap<Customer, CustomerDto>()

.ForMember(dest => dest.Bio, opt => opt.NullSubstitute("N/A"));

var model = AutoMapper.Mapper.Map<IEnumerable<Customer>, IEnumerable<CustomerDto>>(customers);

return View(model);

}

In doing so we will use the same View but now we have “N/A” for “Uncle Leo” bio.

In part2 we will be talking about how to flatten objects by convention.

.NET, Automapper

automapper, C#, object mapping

Starting an Agile Team to become the A Team

Taswar Bhatti January 25, 2011 2 Comments

Here are some recommendations to any team lead or development manager to have effective agile teams.

_{Note: these are just recommendations}

Get a white board for your Kanban or Scrum task and stick iteration tasks on the board publicly not in your office or cubicle
Get every developer 2 monitors, that includes the QA since they should be part of your team. For team lead get them 3. One for monitoring the build or Nabaztag build bunny. Hold people accountable for breaking daily builds (buy donuts, pay a dollar into the pool for pizza, etc)
Every developer machine should have 16G of ram or min 8G, anything less is unacceptable.
Use a source control, bug tracker, and continuous build/integration
Get a Powerful Build machine, install TeamCity or Hudson or CruiseControl or get TFS build agent running, or use the cloud to build.
Get tools like Reflector, Resharper or CodeRush, Test Driver .Net, Code Coverage (dotCover, NCover) and “teach, guide” them how to use it effectively, shortcuts etc
Get a wiki up and running for documentation of how to’s (local build, server build, etc )
Teach the team proper unit testing, whichever framework you choose (NUnit, MbUnit, etc etc)
Teach them mocking, whichever framework you choose (Rhino Mocks, Typemock Isolator, Moq, JustMock, etc) pick one and stick to it
Teach the entire team how to debug effectively, using your IDE, teach them what pdb files are and how to remote debug if in .NET world, if you are in Java teach them how to debug a JVM, in Ruby just have them write unit test 🙂
Have the entire team know about your build and document it on a wiki, don’t just have one person who is the build master due to the bus factor (If build master gets hit by a bus tomorrow who can take over the build?)
Have only max 15 minutes daily stand-ups with format of “What I worked on yesterday, What I am working on today, and are there any impediments.”, there should be no sitting or resting or leaning on an object/wall. If there are extra things that come up, have those people with the team lead meet after the stand-up to resolve those issues.
Provide an area for collaboration, pair programming
Have a code clean up iteration for the team don’t just keep pushing features out. Let the team clean up the mess they have created.
Use a runtime analyzer to see what features users are using, tools like Gibraltar or Runtime Intelligent Service definitely helps, or if you are cheap log things into a logging database with NLog or Log4Net.
Automated! Automated! Automated!, builds, unit test, regression testing, performance testing, everyday there should be reports on what has build, passed and failed.
Provide a learning atmosphere for the team have them showcase some technology, what they have learned, or create knowledge transfer brown bag lunches.
Last but not least make it a fun learning environment for everyone involved, celebrate whenever milestones are reached, take the team out to eat to build trust. (There is something about breaking bread with someone, it builds trust.)

By the end you will have an Agile team that looks like the A Team 🙂

(hidden link in image)

Agile

agile, development, IT, manager, team, team development

Javascript Patterns: Review

Taswar Bhatti January 11, 2011 No Comments

Over the holidays I read Javascript Patterns by Stoyan Stefanov.
Its a pretty light book consisting only of 240 pages, which is light in computer reading, where majority of the books are like yellow pages phone book over 1000 pages. It was quite enjoyable to have a concise book written by Stefanov, another highly recommended book is his Object Oriented Javascript.

Anywayz here is the low down.

Chapter 1. Introduction
This chapter is more of an introduction of using firebug (console.log), jslint, object orientation and prototypes in javascript.

Chapter 2 Essentials
This chapter talks about styles and coding standards, a must read for anyone doing javascript, patterns consisting of the single var variable and minimizing global variables, commenting code, api’s etc

Chapter 3 Literals and Constructors
Its about object literal notation, constructors functions using new, array notations, json, regular expressions and build in types e.g Error consturctor.

Chapter 4 Functions
Contains an indepth use of functions in javascript as first class objects, topics covered were API Patterns (Callback, Configuration objects, returning functions and currying), Initialization patterns (immediate functions, immediate object initalization, init-time branching) and last Performance patterns (Memorization and self-defining functions)

Chapter 5 Object Creation Patterns
One learns about the namespacing pattens, declaring dependencies, private, privileged method. The module patterns, sandbox pattern and last the object constants, static methods, chaining and lastly the method() method.

Chapter 6 Code Reuse Patterns
This chapter talks about inheritance by using borrowing methods, copying properties and mixin in javascript, it also covers classical inheritance but how there are more elegant ways in javascript rather than using the classical way.

Chapter 7 Design Patterns
This chapter goes through 9 GoF patterns and how to implement them in javascript namely Singleton, Factory, Iterator, Decorator, Strategy, Facade, Mediator, Proxy and lastly Observer. The author goes about to show how one can create these patterns in javascript in various ways, it takes a different mind set then the GoF book since javascript is dynamic and functions are first class (GoF was C++ examples in static languagues), if you are a GoF head u should read this chapter.

Chapter 8 DOM and Browser Patterns
The last chapter talks about using javascript in the browser, the author uses mostly YUI, although most of the things covered are already in jquery built in, I wish he covered more on jquery but ohh well. The bonus is he talks about loading javascript how to lazy load script tags and using setTimeOut for long running operations.

Conclusion
All in all I would definitely recommend this book, its not really a beginner book but if you are doing javascript its a definite read.

As I was writing this and finishing up the blog I also saw elegant code has posted a very good review of this books on their blog.

Books, javascript

Book, Javascript, oop, patterns, review

12 Books I will be planning to read in 2011

Taswar Bhatti December 7, 2010 No Comments

Here are some books I am planning to read for 2011, assuming that I complete 1 book a month, I may do more but these are must read for 2011. I will try to do my best to write a review for each.

Books

books, reading, self improvements

Operator ‘==’ cannot be applied to operands of type ‘System.Collections.Generic.KeyValuePair‘ and ‘‘

Taswar Bhatti November 29, 2010 No Comments

You are here beacause you probably got a Linq error, specifically Operator ‘==’ cannot be applied to operands of type ‘System.Collections.Generic.KeyValuePair‘ and ‘‘
So if you wish to do something like this to KeyValuePair using Linq

var item = myDictionary.FirstOrDefault(x => x.Key == 123);
if(item != null)
{
 //blah blah

}

1

2

3

4

5

6

var item = myDictionary.FirstOrDefault(x => x.Key == 123);

if(item != null)

{

//blah blah

}

You will get this error
Operator ‘!=’ cannot be applied to operands of type ‘System.Collections.Generic.KeyValuePair‘ and ‘‘

Since by default KeyValuePairs are struct.
To solve the issue we need to try out this

 var defaultVal = default(KeyValuePair<int, string>);
var item = myDictionary.FirstOrDefault(x => x.Key == 123);
if(!item.Equals(defaultValue)
{
 //blah blah
}

1

2

3

4

5

6

var defaultVal = default(KeyValuePair<int, string>);

var item = myDictionary.FirstOrDefault(x => x.Key == 123);

if(!item.Equals(defaultValue)

{

//blah blah

}

Hope this helps 🙂

.NET, Misc

C#, generics, programming

ASP MVC, Jquery modifying a select drop down with Json data

Taswar Bhatti November 18, 2010 2 Comments

Was coding some new functionality and though I would post this, so that others can find it helpful.
Lets say you have a form that has a checkbox that will update the select dropdown box with different values, when the checkbox is clicked.
Something like the UI below.

Your html code might look like

<input type="hidden" name="fieldId" value="123" />
Parent: <select name="FieldType" id="fieldTypeDropDown">
                        <option value="16">None</option>
                        <option value="4">Apple</option>
                        <option value="3">Orange</option>
                    </select>

Multiple: <input type="checkbox" name="fieldMultiple" id="fieldMultiple" />

1

2

3

4

5

6

7

8

Parent: <select name="FieldType" id="fieldTypeDropDown">

<option value="4">Apple</option>

<option value="3">Orange</option>

</select>

Multiple: <input type="checkbox" name="fieldMultiple" id="fieldMultiple" />

On your server side you would provide a Action Method to filter out the data, something like

[HttpGet]
        public JsonResult GetParents(int parentId, bool isMultiple)
        {
            //get from the database or something which is calling the possible parents 
            List<ParentViewModel> result = GetPossibleParents(parentId, isMultiple);

            IDictionary<string, string> dictionary = new Dictionary<string, string> {{"-1", "None"}};

            foreach(ParentViewModel item in result)
            {
                dictionary.Add(item.Id.ToString(), item.Name);
            }

            return Json(dictionary, JsonRequestBehavior.AllowGet);
        }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

[HttpGet]

public JsonResult GetParents(int parentId, bool isMultiple)

{

//get from the database or something which is calling the possible parents

List<ParentViewModel> result = GetPossibleParents(parentId, isMultiple);

IDictionary<string, string> dictionary = new Dictionary<string, string> {{"-1", "None"}};

foreach(ParentViewModel item in result)

{

dictionary.Add(item.Id.ToString(), item.Name);

}

return Json(dictionary, JsonRequestBehavior.AllowGet);

}

Now we got to add the javascript to listen to the checkbox event changed, something like this in jquery, since we are getting Json Result we will have to parse the json object to populate the dropdown box.

 $('#fieldMultiple').live('change', function() {            
            var fieldId = $('#fieldId').val();
            var isMulti = false;    
            if ($(this).is(':checked')) {
                isMulti = true;                               
            }

            //call ajax now
                $ajax( {type: "POST", url: "someurl", data: { parentId: fieldId, isMultiple: isMulti},
                  success: function(data){
                         var dropDown = $('#fieldTypeDropDown');
                         //remove all the children
                         dropDown.children().remove();
                
                         //add the new children
                         $.each(data, function(key, value) {
                             dropDown.append('<option value="' + key + '">'+ value +"</option>");
                          });
                
                          //create an effect to show its updated
                        dropDown.effect('shake', {times: 4}, 100);
                  }
                });
            }
         });

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

$('#fieldMultiple').live('change', function() {

var fieldId = $('#fieldId').val();

var isMulti = false;

if ($(this).is(':checked')) {

isMulti = true;

}

//call ajax now

$ajax( {type: "POST", url: "someurl", data: { parentId: fieldId, isMultiple: isMulti},

success: function(data){

var dropDown = $('#fieldTypeDropDown');

//remove all the children

dropDown.children().remove();

//add the new children

$.each(data, function(key, value) {

dropDown.append('<option value="' + key + '">'+ value +"</option>");

});

//create an effect to show its updated

dropDown.effect('shake', {times: 4}, 100);

}

});

}

});

By doing so you will have something that shakes and updates the drop down box by some simple ajax calls 🙂

aspmvc, JQuery

asp .net mvc, asp mvc, Javascript, JQuery, mvc

Automapper: Mapping objects Part 5 of 7 (CustomResolver)

Automapper: Mapping objects Part 4 of 7 (Projection)

Automapper: Mapping objects Part 3 of 7 (Nested Mapping)

Automapper: Mapping objects Part 2 of 7 (Flattening by Convention)

Automapper: Mapping objects Part 1 of 7 (NullSubstitution)

Starting an Agile Team to become the A Team

Here are some recommendations to any team lead or development manager to have effective agile teams.

Javascript Patterns: Review

12 Books I will be planning to read in 2011

Operator ‘==’ cannot be applied to operands of type ‘System.Collections.Generic.KeyValuePair‘ and ‘‘

ASP MVC, Jquery modifying a select drop down with Json data

Opinions are my own and not the views of my employer

LinkedIn

My Book

Archives