DotNetDevDude

var - Not an Excuse To Be Lazy

DotNetDevDude — Mon, 30 Jan 2012 16:00:02 GMT

The var keyword was introduced with C# 3.0 and the .NET Framework 3.5 to allow the declaration of implicitly typed variables. The driving force behind the need for implicitly typed variables was the introduction of Anonymous Types.

If you are using var outside of truly anonymous types you are doing so out of laziness. I know this is a bold statement that a lot of developers are going to disagree with, so let me explain.

First off I totally agree that using var can speed up your lines per minute coded and I do use var in this manner. But, I always replace var with the actual type after the fact. You can do this with out requiring a large amount of time after the fact using a tool such as ReSharper and setting up you Clean Up Code” functionality to replace all usages of var with the actual type when possible.

Now for my supporting arguments: *All of which only pertain to using var when the type is not truly anonymous.*

C# is not a Dynamic Language! This may be bad or not ideal but it is fact. The truth is not everyone is fluent in dynamic languages and they are not expecting to read code coded in a dynamic fashion when dealing with C#.
Code written in a dynamic fashion, i.e. implicitly typed , is harder to read, especially when you are not use to reading it. I know what you are saying how is this hard to read?:
1. var x = "This is not hard to read and understand what x is!";

And you are correct, that example is not hard to read and figure what x is. What about this?

var x = from custs in dataContext.Customers
join orders in dataContext.Orders
on custs.CustomerId equals orders.CustomerId
join lines in dataContext.OrderLines
on orders.OrderId equals lines.OrderId
join products in dataContext.Products
on lines.ProductId equals products.ProductId
where products.Name.Contains("FooBar")
where custs.LastName.Contains("Smith")
select products

I would much rather see and read;

IQueryable<Product> x = from custs in dataContext.Customers
join orders in dataContext.Orders
on custs.CustomerId equals orders.CustomerId
where custs.LastName.Contains("Foo")
join lines in dataContext.OrderLines
on orders.OrderId equals lines.OrderId
where lines.Quantity > 10
join products in dataContext.Products
on lines.ProductId equals products.ProductId
where products.Name.Equals("FooBar")
where custs.LastName.Contains("Smith")
select products;

The truth is you know what your result is, at least you better or you have no business writing the code in the first place, so just declare it as such!

One more thing, var has no place in demo code, tutorials, and blog posts. The purpose of demo code, tutorials, and blog posts are to provide education and in doing so the code should be clean and concise and accessible to the masses.

OK, let me have it.

This weblog is sponsored by newtelligence AG. Happy fan of

Entity Framework Code First Spatial Data

DotNetDevDude — Mon, 23 Jan 2012 14:30:40 GMT

Support for spatial data was introduced in SQL Server 2008. What this allows you to do is capture data related to 2D geometric or geographical images in SQL Server. It actually allows you to do much more than just storing a bunch of numbers representing this data. In the initial releases of Entity Framework the spatial data type was not available for use, but with the Entity Framework June 2011 CTP release this functionality is now available.

I am once again working with the code from my Entity Framework Code First Demo post. This simple application is dream car tracker that tracks manufacturers and models of cars that someday I would love to own. As part of the manufacturer data I currently store the Country but would like to be able to map out the corporate headquarters for the day when I get to take a trip and take delivery. I am able to retrieve the latitude and longitude from Google Maps by knowing the address.

The Ferrari factory located at: Via Abetone Inferiore n. 4, I-41053 Maranello Italy has a latitude and longitude of 44.53244, 10.86412. At this point if you are new to the spatial data type, like I was, you are probably thinking “that is just a decimal and you could always store decimals in SQL Server” and you are correct. I could certainly just add two decimal properties to my model that represent latitude and longitude and go on my merry way but using spatial data functionality introduced in the June CTP I get so much more.

Because I am dealing with geographical data and not geometric data I am going to use the DbGeography type, that can be found in System.Data.Spatial, and add a Location property to my Manufacturer model.

Manufacturer.cs

public class Manufacturer {
public long ManufacturerId { get; set; }
[Required]
[StringLength(40)]
public string Name { get; set; }
[Required]
[StringLength(40)]
public string Country { get; set; }
[Required]
public DbGeography Location { get; set; }
#region << Navigation Properties >>
public virtual IList<Model> Models { get; set; }
#endregion
}

Once I have Entity Framework Code First regenerate my database I can take a look and see that the .NET Framework type DbGeography translates to the SQL Server type Geography.

Now that I have my property I can populate the Location data by converting my latitude and longitude values to a DbGeography using the static parse method. I can add this to my SeedManufacturer method.

private void SeedManufacturer(DataContext context) {
_ferrari = new Manufacturer {Name = "Ferrari", Country = "Italy"};
_lamborghini = new Manufacturer {Name = "Lamborghini", Country = "Italy"};
_astonMartin = new Manufacturer {Name = "Aston Martin", Country = "United Kingdom"};
_porsche = new Manufacturer {Name = "Porsche", Country = "Germany"};
_ferrari.Location = DbGeography.Parse("POINT(44.53244 10.86412)");
_lamborghini.Location = DbGeography.Parse("POINT (44.65934 11.12693)");
_astonMartin.Location = DbGeography.Parse("POINT (52.18708 -1.48351)");
_porsche.Location = DbGeography.Parse("POINT (48.83498 9.15231)");
new List<Manufacturer> {_ferrari, _lamborghini, _astonMartin, _porsche}.ForEach(x => context.Manufacturers.Add(x));
}

Now if you look at the data in SQL Server you an see that the data is now represented as a nasty looking hex.

I know you are still wondering what the point is, pun intended! Well, now I can get to the cool part. I can use the methods that come along with DbGeography to do things such as getting distance between two manufacturers as illustrated below in line 3.

Manufacturer ferrari = dc.Manufacturers.First(x => x.Name == "Ferrari");
Manufacturer lamborghini = dc.Manufacturers.First(x => x.Name == "Lamborghini");
double distanceInKilometers = ferrari.Location.Distance(lamborghini.Location);
double distanceInMiles = distanceInKilometers/1609.344;
string outputText = string.Format("{0} is {1} miles from {2}", ferrari.Name, distanceInMiles, lamborghini.Name);

You can also use the methods in LINQ. The query below finds all the manufacturers that are within a 100 mile radius of my house.

DbGeography myHouse = DbGeography.Parse("POINT (4.65934 1.12693)");
IList<Manufacturer> closeToMe = manufacturers.Where(x => (x.Location.Distance(myHouse)*.00062) <= 100).ToList();

This weblog is sponsored by newtelligence AG. Happy fan of

See Me Speak–Visual Studio Live! Las Vegas

DotNetDevDude — Mon, 16 Jan 2012 20:35:00 GMT

I will be talking about ASP.NET MVC4 and jQuery Mobile at Visual Studio Live! Las Vegas in March.

Reach the Mobile Masses With ASP.NET MVC 4 and jQuery Mobile

Creating web applications that will target multiple devices and platforms has become the web developers Holy Grail. Simple HTML pages render without issue no matter what browser or device they are viewed on but who codes simple HTML pages? What happens when you have a business need to hit all mobile platforms?
You don't have to writes hundreds of lines of code to make this happen! In this talk Keith will show how using the latest version of ASP.NET MVC, MVC4, and JQuery you can develop web applications that target iPhone, iPad, Android, Windows Phone 7, and even Blackberry and not have to code and style each platform separately.
You will learn:

How to make your site "viewable" on most user platforms with minimal effort.
How to make your site as usable on all mobile platforms as it is on the desktop browser.
How to do all of this without writing code to target each mobile platform independently.

If you register with my special speaker priority code: VLSPK6 you will save $500 off!

Visual Studio Live Las Vegas

Mirage Resort & Casino

March 26-30, 2012

Event web site: http://vslive.com/lasvegas

Twitter: http://twitter.com/vslive - #vslive

Facebook: http://www.facebook.com – Search “vslive”

LinkedIn: http://www.linkedin.com - - JOIN “vslive” GROUP

Visual Studio Live is five days of practical, Microsoft-supported training for developers to help solve your tough .NET development challenges. You'll find how-to advice and the tips and tricks that you'll be ready to implement as soon as you get back to the office. Our expert faculty - including many Microsoft instructors - makes each session interactive so you can discuss your particular development roadblocks and come away with actionable solutions.

Visual Studio Live Las Vegas offers in-depth training in:

Cloud Computing
Cross Platform Mobile
Data Management
HTML5
Silverlight / WPF
Visual Studio 2010+/.NET 4+
Web
Windows 8/WinRT
Windows Phone 7

Visual Studio Live Las Vegas – Expert Solutions for .NET Developers

This weblog is sponsored by newtelligence AG. Happy fan of

Entity Framework Code First Enum

DotNetDevDude — Mon, 09 Jan 2012 14:18:40 GMT

The most requested feature for Entity Framework has been Enum support for a very long time. At TechEd this year it was announced that Enums would be supported in the next version of the Entity Framework and in June the Entity Framework June CTP was released with Enum support as well some other enhancements.

In the past I dealt with Entity Framework not supporting Enum by having an int property on my model that represented the Enum’s id. My model also had a property of the Enum type that was marked as ignored so that EF did not try create a database column for the property. The setter of the property would set the Enum id field and the getter would convert the Enum id field to the Enum type and return it. If you are confused by that statement, like me, see the code below.

Model.cs

public class Model {
public long ModelId { get; set; }
[Required]
[StringLength(50)]
public string Name { get; set; }
[Required]
public int Year { get; set; }
[Required]
public decimal BasePrice { get; set; }
public int EngineLocation { get; set; }
public EngineLocationType EngineLocationType {
get { return (EngineLocationType) EngineLocation; }
set { EngineLocation = (int) value; }
}
#region << Navigation Properties >>
public long ManufacturerId { get; set; }
public virtual Manufacturer Manufacturer { get; set; }
public virtual IList<Engine> AvailableEngines { get; set; }
#endregion
}

DataContext.cs

public class DataContext : DbContext {
public DataContext() : base("name=EFCodeFirst") {}
public IDbSet<Manufacturer> Manufacturers { get; set; }
public IDbSet<Model> Models { get; set; }
public IDbSet<Engine> Engines { get; set; }
protected override void OnModelCreating(DbModelBuilder modelBuilder) {
modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
modelBuilder.Entity<Model>().Ignore(x => x.EngineLocationType);
modelBuilder.Entity<Model>().HasMany(x => x.AvailableEngines).WithMany(x => x.AvailableOn).Map(x => x.MapLeftKey("ModelId").MapRightKey("EngineId").ToTable("ModelEngine"));
base.OnModelCreating(modelBuilder);
}
}

This gets the job done and really isn’t that messy, but with the new Enum support in the June CTP I can make things cleaner. To make use of the new Enum support all I have to do is declare a property of EngineLocationType in my model and EF will make all the connections for me.

Model.cs

public class Model {
public long ModelId { get; set; }
[Required]
[StringLength(50)]
public string Name { get; set; }
[Required]
public int Year { get; set; }
[Required]
public decimal BasePrice { get; set; }
public EngineLocationType EngineLocation { get; set; }
#region << Relationships >>
public long ManufacturerId { get; set; }
public virtual Manufacturer Manufacturer { get; set; }
public virtual IList<Engine> AvailableEngines { get; set; }
#endregion
}

So that is the new EF Enum support. The only issue I have with the implementation is that ideally I would like to be able to have an EngineLocationType table in my database that Entity Framework would create and populate based on my Enum definition and assign a foreign key relationship to EngineLocation on my Model entity. That would make the entire process complete and architecturally sound IMHO.

If you are looking for a code download this is part of the Entity Framework Code First Demo that I did in a previous blog post and the code is available on GitHub.

This weblog is sponsored by newtelligence AG. Happy fan of

Simplify Integration Testing With Entity Framework Code First

DotNetDevDude — Mon, 12 Dec 2011 15:25:24 GMT

Integration Testing is a necessary evil that often gets overlooked or is implemented, ran once, and then not maintained. The reasoning behind this is that by definition Integration Testing relies on external resources that are often outside of our control and some times completely hands off. Also these external resources are in constant use by a large number of people making whatever resource the external systems are serving very volatile. In this post I am going to focus on the most common external resource; the Database.

Integration Testing when you have a Database as an external resource can be a nightmare. First off you need to have access to the database. Once that is accomplished you need to have elevated access to the database in order to run scripts. Scripts you say? Yes scripts! Scripts that can put the database in an expected state every time you run the Integration Tests. Oh, yeah then you have to make sure that the script is run.

Luckily if you are using Entity Framework Code First you more than likely already have elevated access to the Database and are probably running a local instance of SQL Server on your dev box that you are in control of. But in the typical scenario you would still have to write the SQL Scripts, which if you are like me you don’t enjoy, and then you have to make sure they are run and that they don’t impact the data that you use to manually UI test your application…we all have that one piece of data that rely on…don’t deny it!

So how does EF Code First help me with this overwhelming problem?

All example code is from my EFCodeFirstDemo.

Seeded Data:

In Entity Framework Code First you are given the ability to hook into the database generation process and seed the database with relevant data for testing. The best part about this is that you do it all using your POCO domain entities and LINQ to Entities…NO SQL SCRIPTS! WOOT!

The first step in the process is to create a custom data context initializer that implements an implementation IDatabaseInitializer.

DropCreateDatabaseIfModelChanges
DropCreateDatabaseAlways

public class TestDataContextInitializer : DropCreateDatabaseIfModelChanges<DataContext> {}

The next step is to override the Seed method that hooks into the generation of the database.

protected override void Seed(DataContext context) {
base.Seed(context);
}

Finally you can use this Seed method to build up your test data and populate the database either every time your model changes (DropCreateDatabaseIfModelChanges) or if you choose every time you spin up a new session that accesses the database (DropCreateDatabaseAlways), I don’t recommend the latter.

In the code below I am building up object graphs using my standard POCO entities and LINQ to Entities.

public class TestDataContextInitializer : DropCreateDatabaseIfModelChanges<DataContext> {

private Manufacturer _astonMartin;
private Model _astonMartinDB9;
private Engine _astonMartinV12;
private Model _astonMartinV12Vantage;
private Manufacturer _ferrari;
private Model _ferrari458Italia;
private Model _ferrariScaglietti;
private Engine _ferrariV12;
private Engine _ferrariV8;
private Manufacturer _lamborghini;
private Model _lamborghiniAventador;
private Model _lamborghiniGallardo;
private Engine _lamborghiniV10;
private Engine _lamborghiniV12;
private Manufacturer _porsche;
private Model _porsche911GT2R2;
private Engine _porscheStraight6;

protected override void Seed(DataContext context) {
SeedManufacturer(context);
SeedEngine(context);
SeedModel(context);
base.Seed(context);
}

private void SeedManufacturer(DataContext context) {
_ferrari = new Manufacturer {Name = "Ferrari", Country = "Italy"};
_lamborghini = new Manufacturer {Name = "Lamborghini", Country = "Italy"};
_astonMartin = new Manufacturer {Name = "Aston Martin", Country = "United Kingdom"};
_porsche = new Manufacturer {Name = "Porsche", Country = "Germany"};
_ferrari.Location = DbGeography.Parse("POINT(44.53244 10.86412)");
_lamborghini.Location = DbGeography.Parse("POINT (44.65934 11.12693)");
_astonMartin.Location = DbGeography.Parse("POINT (52.18708 -1.48351)");
_porsche.Location = DbGeography.Parse("POINT (48.83498 9.15231)");
new List<Manufacturer> {_ferrari, _lamborghini, _astonMartin, _porsche}.ForEach(x => context.Manufacturers.Add(x));
}

private void SeedEngine(DataContext context) {
_astonMartinV12 = new Engine {Name = "6.0L V12", BreakHorsepower = 510, NumberOfCylinders = 12, Liters = 6.0m};
_ferrariV8 = new Engine {Name = "5.4L V8", BreakHorsepower = 570, NumberOfCylinders = 8, Liters = 5.4m};
_ferrariV12 = new Engine {Name = "5.7L V12", BreakHorsepower = 532, NumberOfCylinders = 12, Liters = 5.7m};
_lamborghiniV10 = new Engine {Name = "5.2L V10", BreakHorsepower = 562, NumberOfCylinders = 10, Liters = 5.2m};
_lamborghiniV12 = new Engine {Name = "6.5L V12", BreakHorsepower = 700, NumberOfCylinders = 12, Liters = 6.5m};
_lamborghiniV12 = new Engine {Name = "6.5L V12", BreakHorsepower = 700, NumberOfCylinders = 12, Liters = 6.5m};
_porscheStraight6 = new Engine {Name = "3.6L Straight 6", BreakHorsepower = 620, NumberOfCylinders = 6, Liters = 3.6m};
new List<Engine> {_astonMartinV12, _ferrariV8, _ferrariV12, _lamborghiniV10, _lamborghiniV12, _porscheStraight6}.ForEach(x => context.Engines.Add(x));
}

private void SeedModel(DataContext context) {
_ferrari458Italia = new Model {Name = "458 Italia", BasePrice = 220000, Year = 2012, Manufacturer = _ferrari, AvailableEngines = new List<Engine> {_ferrariV8, _ferrariV12}, EngineLocation = EngineLocationType.Mid};
_ferrariScaglietti = new Model {Name = "Scaglietti", BasePrice = 313000, Year = 2012, Manufacturer = _ferrari, AvailableEngines = new List<Engine> {_ferrariV12}, EngineLocation = EngineLocationType.Front};
_lamborghiniGallardo = new Model {Name = "Gallardo LP 570-4 Superleggera", BasePrice = 237600, Year = 2012, Manufacturer = _lamborghini, AvailableEngines = new List<Engine> {_lamborghiniV10}, EngineLocation = EngineLocationType.Mid};
_lamborghiniAventador = new Model {Name = "Aventador LP 700-4", BasePrice = 387000, Year = 2012, Manufacturer = _lamborghini, AvailableEngines = new List<Engine> {_lamborghiniV12}, EngineLocation = EngineLocationType.Mid};
_astonMartinDB9 = new Model {Name = "DB9", BasePrice = 185000, Year = 2012, Manufacturer = _astonMartin, AvailableEngines = new List<Engine> {_astonMartinV12}, EngineLocation = EngineLocationType.Front};
_astonMartinV12Vantage = new Model {Name = "V12 Vantage", BasePrice = 180000, Year = 2012, Manufacturer = _astonMartin, AvailableEngines = new List<Engine> {_astonMartinV12}, EngineLocation = EngineLocationType.Mid};
_porsche911GT2R2 = new Model {Name = "911 GT2 R2", BasePrice = 245000, Year = 2012, Manufacturer = _porsche, AvailableEngines = new List<Engine> {_porscheStraight6}, EngineLocation = EngineLocationType.Rear};
new List<Model> {_ferrari458Italia, _ferrariScaglietti, _lamborghiniAventador, _lamborghiniGallardo, _astonMartinDB9, _astonMartinV12Vantage, _porsche911GT2R2}.ForEach(x => context.Models.Add(x));
}
}

The result of this process is that every time my database is dropped and recreated it is also seeded with test data.

I know what your saying…”But I don’t use the same data for manually walking through my UI that I would use for Integration Testing!” Luckily I can easily specify a different Connection String and Database Initializer to use when running my Integration Tests.

The first thing you have to do is modify the connection string in the AppConfig of your Integration Test project to use a different initial catalog. As you can see all I did was suffix mine with “_TEST”…clever I know! This is going to setup a new database for you that will only be used for testing.

<connectionStrings>
< add name="EFCodeFirst" connectionString="Data Source=(local);Initial Catalog=EFCodeFirst_TEST;Integrated Security=True;MultipleActiveResultSets=True;" providerName="System.Data.SqlClient"/>
connectionStrings>

Next you need to tell EF what Database Initializer to use. This can be accomplished two ways. The first way is to explicitly set it in code. In the example below I am doing this in the ClassInitialize of my Integration Test class.

[ClassInitialize]
public static void ClassInitialize(TestContext context) {
Database.SetInitializer(new TestDataContextInitializer());
}

The second way is to set it configure it in the App/Web Config.

<appSettings>
< add key="DatabaseInitializerForType EFCodeFirst.DataContext.DataContext, EFCodeFirst" value="EFCodeFirst.DataContext.TestDataContextInitializer, EFCodeFirst" />
appSettings>

That’s it! Now you have a separate Database instance just for Integration Testing that will always contain the clean fresh data that is required to exercise your Integration Test suite. Better yet, every developer that runs your Integration Tests will also have this data and everything will just work.

This weblog is sponsored by newtelligence AG. Happy fan of

EF Code First Configuration–When to Use Fluent API and When To Use Attributes

DotNetDevDude — Mon, 05 Dec 2011 14:53:57 GMT

Configuration of Entity Framework Code First is a necessary evil and you have to admit is a very well designed user friendly process. But, in typical Microsoft fashion, the EF developers have given us more than one way to perform this configuration.

Fluent API
1. Fluent expression based configuration
2. Performed during the OnModelCreating process of the DbContext.
3. Allows for complex configurations that are not possible via Attribute based configuration
  Fluent Configuration
  protected override void OnModelCreating(DbModelBuilder modelBuilder) {
  
  modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
  
  modelBuilder.Entity<Model>().HasMany(x => x.AvailableEngines)
  
  .WithMany(x => x.AvailableOn)
  
  .Map(x => x.MapLeftKey("ModelId")
  
  .MapRightKey("EngineId")
  
  .ToTable("ModelEngine"));
  
  modelBuilder.Entity<Model>().Ignore(x => x.SomeDerivedProperty);
  
  base.OnModelCreating(modelBuilder);
  
  }
Attributes
1. Attribute based configuration
2. Performed directly on the Domain Model Class/Property being configured
3. Allows the non-EF specific attributes to be used in other pieces of your application
4. Allows validation of your Model at any time
  Attribute Configuration
  public class Manufacturer {
  
  public long ManufacturerId { get; set; }
  
  [StringLength(40)]
  
  [Required]
  
  public string Name { get; set; }
  
  [Required]
  
  [StringLength(40)]
  
  public string Country { get; set; }
  
  [Required]
  
  public DbGeography Location { get; set; }
  
  #region << Relationships >>
  
  public virtual IList<Model> Models { get; set; }
  
  #endregion
  
  }

So…When do you use which!?

Use Fluent Configuration When:

Configuration is being done solely to make the database behave correctly.
Configuration has no effect on the design and/or behavior of your Domain Model.
Examples:
- Specifying the database table the Domain Model is to be mapped to
- Specifying the database table column the Domain Model Field is to be mapped to
- Ignoring a Domain Model Field
- Configuring the keys and table names for relationships not able to be picked up by EF

Use Attribute Configuration When:

Configuration solely applies to your Domain Model.
Configuration has no effect on the design and/or behavior of your Database.
Examples:
- Making a field Required
- Validating a field (String length, Range, etc.)
Also…Don’t forget that for the most part these Attributes are not EF specific and can be used in the UI with MVC.

This weblog is sponsored by newtelligence AG. Happy fan of

jQuery Accordion Item with no Children as Link

DotNetDevDude — Mon, 28 Nov 2011 15:52:57 GMT

The jQuery Accordion control is great for creating rich interactive HTML menus. I used it in a recent project where I wanted “Home” to be the top menu option. I Googled around and wasn’t able to find a way to have a menu item with no children link to some URL. So I played around for a bit and came up this solution.

$(function()
{

 $("#navigationMenu").accordion({ autoHeight: false });

 $('#homeNavMenu').find('a').click(function()
{ window.location = '/';
});

});

This weblog is sponsored by newtelligence AG. Happy fan of

ASP.NET MVC–Redirect to Custom Page when User is not Authorized

DotNetDevDude — Mon, 21 Nov 2011 15:46:18 GMT

If you ever need to redirect to a custom page in ASP.NET MVC when a user is either not authenticated or not authorized here is how you do it.

Create a custom attribute that inherits from AuthorizeAttribute.
Override the OnAuthorization method.
- call the base OnAuthorization
- Handle user not being authenticated
- Handle user not being authorized
Use the newly created attribute in your controller in place of the ASP.NET Authorize attribute

The
Custom Attribute

public class CustomAuthorizeAttribute : AuthorizeAttribute {

 public override void OnAuthorization(AuthorizationContext filterContext)
{

 base.OnAuthorization(filterContext);

 if (!filterContext.HttpContext.User.Identity.IsAuthenticated)
{

 filterContext.Result = new RedirectResult("~/Account/Logon");

 return;

 }

 if (filterContext.Result is HttpUnauthorizedResult)
{

 filterContext.Result = new RedirectResult("~/Account/AccessDenied");

 return;

 }

 }

}

Example
Controller Usage

[CustomAuthorize(Roles = ("Admin,Manager"))]

public ActionResult Index()
{

 return View("Index");

}

This weblog is sponsored by newtelligence AG. Happy fan of

ASP.NET MVC 3 --- DropDownListFor Enum

DotNetDevDude — Mon, 14 Nov 2011 14:46:32 GMT

ASP.NET MVC has an HTML Helper DropDownListFor that takes an IEnumerable and creates a drop down list for it. Often you want to create a drop down list for an Enum. Of course you can do this without using an HTML Helper and use standard HTML controls but you don’t have the standard clean view code that HTML Helpers give you. Extending and creating your own HTML Helpers is rather easy, as demonstrated in my last post. With that in mind I created an extension to DropDownListFor that will create a drop down list for an Enum type.

Enum
Html Helper

using System.Collections.Generic;

using System.Linq;

using System.Linq.Expressions;

using DropDownListForEnumDemo.Extensions;

namespace System.Web.Mvc.Html {

 public static class EnumHtmlHelper {

 public static MvcHtmlString DropDownListFor<TModel, TEnum>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel,
TEnum>> expression)
{

 return DropDownListFor(htmlHelper, expression, null, null);

 }

 public static MvcHtmlString DropDownListFor<TModel, TEnum>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel,
TEnum>> expression, string optionLabel)
{

 return DropDownListFor(htmlHelper, expression, optionLabel, null);

 }

 public static MvcHtmlString DropDownListFor<TModel, TEnum>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel,
TEnum>> expression, object htmlAttributes)
{

 return DropDownListFor(htmlHelper, expression, null, htmlAttributes);

 }

 public static MvcHtmlString DropDownListFor<TModel, TEnum>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel,
TEnum>> expression, string optionLabel, object htmlAttributes)
{

 ModelMetadata metadata = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);

 Type enumType = Nullable.GetUnderlyingType(typeof (TEnum)) ?? typeof (TEnum);

 IEnumerable<TEnum> enumValues = Enum.GetValues(enumType).Cast<TEnum>();

 IEnumerable<SelectListItem> items = enumValues.Select(e => new SelectListItem {Text = e.ToString().FromCamelToProperCase(), Value = e.ToString(), Selected = e.Equals(metadata.Model)});

 if (optionLabel != null)
{

 new[]
{new SelectListItem {Text = optionLabel}}.Concat(items);

 }

 return htmlHelper.DropDownListFor(expression, items, optionLabel, htmlAttributes);

 }

 }

}

Enum

namespace DropDownListForEnumDemo.Enumerations {

 public enum Cars {

 FerrariItalia = 0,

 LamborghiniGallardoLP560,

 LamborghiniAventador,

 AstonMartinVantage,

 Porsche911GT2,

 }

}

Model

namespace DropDownListForEnumDemo.Models {

 public class CarsModel {

 [Display(Name = "Select
A Car:")]

 [Required(ErrorMessage = "*
Required")]

 public Cars? SelectedCar { get; set;
}

 }

}

View

@{ViewBag.Title = "Home
Page";}

@using DropDownListForEnumDemo.Models

@model CarsModel

<h2>@ViewBag.Message</h2>

@using (Html.BeginForm())
{

 <div>

 <fieldset>

 <div class="editor-label">

@Html.LabelFor(m => m.SelectedCar)

 </div>

 <div class="editor-field">

@Html.DropDownListFor(m => m.SelectedCar, "--
Select --")

@Html.ValidationMessageFor(m => m.SelectedCar)

 </div>

 </fieldset>

 <input type="submit" value="Click
Me"/>

 </div>

}

Note: Because enumeration values have to adhere to the same naming conventions as variables I had to work some magic to get the display values formatted correctly. OK, it’s really not magic…just a little RegEx Voo-Doo.

The code is available on GitHub

This weblog is sponsored by newtelligence AG. Happy fan of

ASP.NET MVC–ActionLink Button

DotNetDevDude — Mon, 07 Nov 2011 14:53:15 GMT

ASP.NET MVC provides a lot of HTML Helpers that allow you to more easily with less code create your views. Typically navigation in MVC is done using the ActionLink HTML Helper that allows you easily generate an html anchor tag that will redirect to a specified controller and action. I found cases where I wanted my navigation to be done via a button rather than a link so I created my own HTML Helper to make this easier.

Code:

using System.Web.Routing; 

namespace System.Web.Mvc.Html { 

    public static class ActionLinkButtonHelper { 

        public static MvcHtmlString ActionLinkButton(this HtmlHelper htmlHelper, string buttonText, string actionName, string controllerName, RouteValueDictionary routeValues)
{ 

            string href = UrlHelper.GenerateUrl("default", actionName, controllerName, routeValues, RouteTable.Routes, htmlHelper.ViewContext.RequestContext, false); 

            string buttonHtml = string.Format("<input
type=\"button\" title=\"{0}\"
value=\"{0}\"
onclick=\"location.href='{1}'\"
class=\"button\" />",buttonText,href); 

            return new MvcHtmlString(buttonHtml); 

        } 

    } 

}

Example Usage:

@Html.ActionLinkButton("Add", "AddSiteFromDistrict", "SiteMaintenance", new RouteValueDictionary(new { districtID = @Model.DistrictID })) 

This weblog is sponsored by newtelligence AG. Happy fan of