0

I've seen somewhere how to do this before on a blog but I forgot where or how. Lets say I have a domain in a class library. I'd like to data annotate the properties of this domain as my viewmodel in the web project.

How do I accomplish this?

For example. This domain is in my class library:

public class Person {
   public int Id {get; set;}
   public string FirstName {get; set;}
}

In my web project, there is this:

//Do i need to set some attribute here?
public class CreatePersonViewModel{

   [Required()]
   [DisplayName("First Name")]
   public string FirstName {get; set;}
}

This code can be mapped to Person without a tool. Probably partial or something.

Shawn Mclean
  • 56,733
  • 95
  • 279
  • 406
  • no, you don't need to set an attribute where you have `//Do I need to set some attribute here?`. If your controller action has a parameter type of `CreatePersonViewModel`, the validation attributes will run to determine if the `ModelState` is valid. – Russ Cam Feb 09 '11 at 21:45
  • 2
    I downvoted all the answers that encourage the use of Metadata classes. Metadata buddy classes totally invalidates the purpose of having a domain or separations of concerns. The UI should point inward at your domain not the domain pointing out to your UI. Thats a terrible practice that should be discouraged. – John Farrell Feb 10 '11 at 04:04
  • @jfar: strictly speaking, a metadata class is separating a concern - though it's not something that you'd do lightly. It's all well and good to be opinionated, but your actions here do a disservice: in the case where your model is generated it is quite likely that you can't annotate the actual properties, but highly likely that you can add an attribute to the partial class definition. – JT. Mar 16 '11 at 22:35

4 Answers4

4

The whole idea of using a view model is to decouple it from your domain model and to have something which is adapted to the needs of the view. The view model should be declared in the web project and contain all the necessary properties and formatting attributes that this particular view might require. The domain model shouldn't be polluted with any view specific data annotations. So if your model looks like this:

public class Person {
   public int Id { get; set; }
   public string FirstName { get; set; }
}

You could have the following view model:

public class CreatePersonViewModel {
   [Required]
   [DisplayName("First Name")]
   public string FirstName { get; set; }
}

and then have the controller fetch the model from some repository, map it to the view model (AutoMapper can help you here) and pass the view model to the view.

Darin Dimitrov
  • 1,023,142
  • 271
  • 3,287
  • 2,928
  • I don't agree - I have my annotations declared in my data layer because the database field "TownSuburb" is always going to have a label of "Town/Suburb"... why would I want to set this up in my view 2, 3, 4 times for different components of my sites as I am sharing the database across multiple front-ends? – Rob Feb 10 '11 at 06:52
  • @Rob, because you are tying your model to a particular presentation. What if in another application this field should be called something else? – Darin Dimitrov Feb 10 '11 at 18:11
  • That's correct so this answer isn't correct - the right answer would be "it depends on the domain" - Additionally why would you want to decouple validation rules specific to database columns? You are not going to want to change the validation rules for an INT column so why not tightly couple it with the model? – Rob Feb 13 '11 at 00:08
1

Are you talking about this type of thing?:

using System.ComponentModel.DataAnnotations;

public MyClass
{


    [DisplayName("Street Address")]
    public string StreetAddress { get; set; }

}

EDIT:

If you need to add Data Annotations to generated class like an Entity do this:

using System.ComponentModel.DataAnnotations;
using System.ComponentModel;

namespace Something

{
    [MetadataType(typeof(MetaMyClass))]
    public partial class MyClass
    {
          //You can just leave this empty if you have nothing additional to add to the class

    }

    public class MetaMyClass
    {
        [DisplayName("Street Address")]
        public string StreetAddress { get; set; }
    }
 }
Rob
  • 10,004
  • 5
  • 61
  • 91
  • yes, but `MyClass` already exist and I cannot use `[DisplayName("Street Address")]` on it. There is a way to add annotations to it. – Shawn Mclean Feb 09 '11 at 21:37
1

Do you mean annotate your Domain objects or your view model objects?

Using the System.ComponentModel.DataAnnotations validation attributes (and deriving any of your own from ValidationAttribute, you can validate values bound to the properties of your viewmodel at the point of model binding.

Scott Guthrie has a detailed blog post about Model validation with data annotation validation attributes.

EDIT: you say in a comment to another poster that your types already exist. You can add the MetadataTypeAttribute to the existing type to indicate another type that holds the validation logic to be applied to the properties of your existing type.

Russ Cam
  • 124,184
  • 33
  • 204
  • 266
  • I'm looking at this: http://stackoverflow.com/questions/1882338/can-i-add-mvc-2-dataannotation-attributes-to-existing-properties/1882428#1882428 I cannot put `[MetadataTypeAttribute]` on the original model because it does not know about the viewmodel. Or is that the other way around? – Shawn Mclean Feb 09 '11 at 21:44
  • The idea behind viewmodels is that they are intended to pass data to (and from) your views into your controllers. They don't necessarily have a `code` association with your domain objects (like an attribute associating them, inheritance, etc). Inside of your controller, you would likely perform mapping of values between your view model and domain object. You *could* not use view models and simply pass domain objects to the views, but there are certain issues to be aware of when doing this due to how model validation works. – Russ Cam Feb 09 '11 at 21:57
  • Take a look at Brad Wilson's post on model validation - http://bradwilson.typepad.com/blog/2010/01/input-validation-vs-model-validation-in-aspnet-mvc.html. He talks about the shift from input validation to model validation between MVC 1 and MVC 2, respectively, but what he says about model validation still applies to MVC 2 and MVC 3. – Russ Cam Feb 09 '11 at 22:01
1

You can create a 'buddy' class for your data annotation attributes

[MetadataType(typeof(ResourceMetadata))]
public partial class Resource
{
   public object Value { get; set; }
}

public class ResourceMetadata
{
  // The metadata class can define hints  

  [UIHint("ResourceValue")]
  public object Value { get; set; }
}
Jakub Konecki
  • 45,581
  • 7
  • 87
  • 126