Model state validation is easy with DataAnnotations. However, you will find repeating the next line of code very soon:
…
if(!ModelState.IsValid) return BadRequest(..);
…
Luckily, there is a pretty simple solution – to use ActionFilter:
All you have to do is to add the ValidateModel attribute to your controller methods that require model state validation.
Using Entity Framework is extremely easy and straight forward unless you have a large amount of entities and business rules to apply. You are lucky if you have a code first approach, however some times database first approach is in place and there are some limitations. For example, as the DbContext is autogenerated using T4, it is hard to introduce general behaviours, like updating CreatedAt, UpdatedAt and DeletedAt properties globally upon saving.
There could be different solutions for the problem I mentioned earlier, however there is a simple one that may work as well. Since all auto-generated files by EntityFramework marked as partial, we could easily extend them. Lets start!
Continue reading “Entity Framework Database First Generalising Timestamps”
Implementing INotifyPropertyChange is pretty straightforward. Usually, you create a base ViewModel class which implements it and which usually contains RaisePropertyChanged method:
public abstract class BaseViewModel : INotifyPropertyChanged
{
#region INotifyPropertyChanged
public event PropertyChangedEventHandler PropertyChanged;
protected void RaisePropertyChanged(
[CallerMemberName] string propertyName = ““)
{
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
#endregion
}
Now you can extend the BaseViewModel and use it this way:
For very small applications it can be a good enough approach, however, in bigger applications it turns into a lot of boring boilerplate code. Here is where NotifyPropertyChanged.Fody comes into play! With this nice package our code will turn into:
Easy as it is! I highly recommend to get familiar with the documentation as it contains a lot of useful information about more advanced flows. For example, if you need to RaisePropertyChange for dependent properties or to skip equality comparison.
First I tried to keep it simple: to give up on seconds and use UIDatePicker in UIDatePickeCountDownMode. So the end result will look like this:
Legacy backend API endpoint returns JSON with units in an uncommon manner.
Instead of returning the measurement system “imperial” or “metric” it returns “kgs” or “lbs”.
Using JSON.net deserialize & serialize “kgs” to “metric” and “lbs” to “imperial” in our front-end app.
The solution is pretty simple. We have to define an enum, with “EnumMember” attributes on each element and use “StringEnumConverter” as preferred JsonConvertor. Here is the full and working example:
using System;
using System.Runtime.Serialization;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
namespace JSONnetEnums
{
class Program
{
static void Main(string[] args)
{
var deserializedObj =
JsonConvert.DeserializeObject<Foo>(“{\”Unit\”:\”kgs\”}“);
Console.WriteLine(deserializedObj.Unit);
// Output: Metric
var serializedObj =
JsonConvert.SerializeObject(new Foo { Unit = Unit.Imperial });
Console.WriteLine(serializedObj);
// Output: {“Unit”:”lbs”}
}
}
class Foo
{
public Unit Unit { get; set; }
}
[JsonConverter(typeof(StringEnumConverter))]
enum Unit
{
[EnumMember(Value = “kgs“)]
Metric,
[EnumMember(Value = “lbs“)]
Imperial
}
}
Communicating with backend in JSON can be challenging.
In case of C# model which by convention should be in CamelCase notation and backend which is using snake_notation we can easily solve the problem with Json.NET.
For example, we have the next model:
public class Model
{
public string FooBar { get; set; }
}
and we want it to be serialised to: { “foo_bar”: “” }
We could use an attribute:
[JsonProperty(PropertyName = "foo_bar")]
public string FooBar { get; set; }
That will work, however, if we want to generalise this strategy we should create a JsonSerializerSettings with DefaultContactResolver which is using SnakeCaseNamingStrategy and to use it while serialisation/deserialization:
public class JsonCoverter : IJsonConverter
{
private static JsonSerializerSettings defaultJsonSerializerSettings =
new JsonSerializerSettings
{
ContractResolver = new DefaultContractResolver
{
NamingStrategy = new SnakeCaseNamingStrategy()
}
};
public T Deserialize(string json) =>
JsonConvert.DeserializeObject(json, defaultJsonSerializerSettings);
public string Serialize(object obj) =>
JsonConvert.SerializeObject(obj, defaultJsonSerializerSettings);
}
Using the JsonConverter globally will solve the different notation problem.
