How can i ignore errors in json deserialization using [FromBody]?

It sounds like you need a custom converter (as also mentioned in the comments).

public class YourCustomConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return objectType.IsAssignableFrom(typeof(double));
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        try
        {
            return serializer.Deserialize<double>(reader);
        }
        catch
        {
            return 0d;
        }
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        serializer.Serialize(writer, value);
    }
}

Now you just decorate the properties you want this to be valid for with JsonConverter. For your example it would look like this:

public class Location
{
    public string Name { get; set; }

    [JsonConverter(typeof(YourCustomConverter))]
    public double Latitude { get; set; }

    [JsonConverter(typeof(YourCustomConverter))]
    public double Longitude { get; set; }
}

Now, if you send in invalid data, the deserializer will throw an exception, which is catched by the custom converter that returns 0 instead (or whatever value you want it to be).

UPDATE:

Disclaimer: This is untested!

You could probably make a generic converter to handle all cases:

public class YourCustomConverter<T> : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return objectType.IsAssignableFrom(typeof(T));
    }
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        try
        {
            return serializer.Deserialize<T>(reader);
        }
        catch
        {
            return default(T);
        }
    }
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        serializer.Serialize(writer, value);
    }
}

You could still use this as an attribute [JsonConverter(typeof(YourCustomConverter<double>)].

There's also an option to use a custom converter for all JSON serialization/deserialization using this code:

services.AddMvc().AddNewtonsoftJson(options =>
{
    // Configure a custom converter
    options.SerializerOptions.Converters.Add(new SomeOtherCustomJsonConverter());
});

However, this can't really be made generic so you would have to write your own handling of all your possible types.

This JsonConverter worked for me:

public class DoubleJsonConverter : JsonConverter<double>
{
    public override double Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        try
        {
            return reader.GetDouble();
        }
        catch (Exception)
        {
            return 0.0;
        }
    }

    public override void Write(Utf8JsonWriter writer, double value, JsonSerializerOptions options)
    {
        try
        {
            writer.WriteNumberValue((decimal)value);
        }
        catch (Exception)
        {
            writer.WriteNumberValue(0.0);
        }
    }
}

Don't forget

using System.Text.Json.Serialization;

And

public class Location
{
    public string Name { get; set; }

    [JsonConverter(typeof(DoubleJsonConverter))]
    public double Latitude { get; set; }

    [JsonConverter(typeof(DoubleJsonConverter))]
    public double Longitude { get; set; }
}

The actual solution is a combination of GTHvidstens answer and OPs answer.

Using the generic JsonConverter<T> is correct but you should not use Convert.ChangeType and Activator.CreateInstance, that part was better in GTHvidstens answer.

Below is the final version which should be faster (and arguably just more correct) than OPs version by using default(T) and serialize.Deserialize, while also taking advantage of the generic JsonConverter<T> used in OPs answer.

public class ErrorIgnoringJsonConverter<T> : JsonConverter<T>
{
    public override bool CanWrite => false;
    public override bool CanRead => true;

    public override T ReadJson(JsonReader reader, Type objectType, T existingValue, bool hasExistingValue, JsonSerializer serializer)
    {
        try
        {
            return serializer.Deserialize<T>(reader);
        }
        catch
        {
            return default(T);
        }
    }

    public override void WriteJson(JsonWriter writer, T value, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

What you do with this converter doesn't matter. One possible solution which will work is the one OP posted already - I don't see any issues with this approach.

services
    .AddMvc()
    .AddNewtonsoftJson(options =>
        {
            options.SerializerSettings.Converters.Add(new ErrorIgnoringJsonConverter<bool>());
            options.SerializerSettings.Converters.Add(new ErrorIgnoringJsonConverter<int>());
            options.SerializerSettings.Converters.Add(new ErrorIgnoringJsonConverter<long>());
            options.SerializerSettings.Converters.Add(new ErrorIgnoringJsonConverter<float>());
            options.SerializerSettings.Converters.Add(new ErrorIgnoringJsonConverter<double>());
            options.SerializerSettings.Converters.Add(new ErrorIgnoringJsonConverter<decimal>());
            options.SerializerSettings.Converters.Add(new ErrorIgnoringJsonConverter<DateTime>());
        });

Thank everybody for help, the solution for me was:

public class ErrorIgnoringJsonConverter<T> : JsonConverter<T>
{
    public override bool CanWrite => false;

    public override T ReadJson(JsonReader reader, Type objectType, T existingValue, bool hasExistingValue, JsonSerializer serializer)
    {
        try
        {
            return (T)Convert.ChangeType(reader.Value, typeof(T));
        }
        catch (Exception)
        {
            return Activator.CreateInstance<T>();
        }
    }

    public override void WriteJson(JsonWriter writer, T value, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

And adding it in startup:

services.AddMvc().AddNewtonsoftJson(options =>
        {
            options.SerializerSettings.Converters.Add(new ErrorIgnoringJsonConverter<bool>());
            options.SerializerSettings.Converters.Add(new ErrorIgnoringJsonConverter<int>());
            options.SerializerSettings.Converters.Add(new ErrorIgnoringJsonConverter<long>());
            options.SerializerSettings.Converters.Add(new ErrorIgnoringJsonConverter<float>());
            options.SerializerSettings.Converters.Add(new ErrorIgnoringJsonConverter<double>());
            options.SerializerSettings.Converters.Add(new ErrorIgnoringJsonConverter<decimal>());
            options.SerializerSettings.Converters.Add(new ErrorIgnoringJsonConverter<DateTime>());
        });