$ git branch | grep -v "master" | xargs git branch -D

modelBuilder.Entity<Blog>()
    .Property(b => b.Url)
    .HasField("_validatedUrl")
    .UsePropertyAccessMode(PropertyAccessMode.Field);

public class Blog
{
    private string _validatedUrl;

    public int BlogId { get; set; }

    public string GetUrl()
    {
        return _validatedUrl; 
    }

    public void SetUrl(string url)
    {
        using (var client = new HttpClient())
        {
            var response = client.GetAsync(url).Result;
            response.EnsureSuccessStatusCode();
        }

        _validatedUrl = url;
    }
}

modelBuilder.UsePropertyAccessMode(PropertyAccessMode.Property);

services.AddMvc()
    .SetCompatibilityVersion(CompatibilityVersion.Version_2_2)
    .ConfigureApiBehaviorOptions(options =>
    {
        options.InvalidModelStateResponseFactory = context =>
        {
            var problemDetails = new ValidationProblemDetails(context.ModelState)
            {
                Type = "https://contoso.com/probs/modelvalidation",
                Title = "One or more model validation errors occurred.",
                Status = StatusCodes.Status400BadRequest,
                Detail = "See the errors property for details.",
                Instance = context.HttpContext.Request.Path
            };

            return new BadRequestObjectResult(problemDetails)
            {
                ContentTypes = { "application/problem+json" }
            };
        };
    });

public class MemberTest : IClassFixture<TestStartup>
    {
        private readonly TestStartup testStartup;
        private readonly DatabaseSeedService seedService;
        public MemberTest(TestStartup testStartup)
        {
            this.testStartup = testStartup;
            this.seedService = this.testStartup.GetService<DatabaseSeedService>();
        }

        [Fact]
        public async Task Add_InsertMember_ReturnOKResponse()
        {
            // ...
        }
    }

 var result = _properties.AddOrUpdate(key
                  k =>
                  {
                      Console.WriteLine("AddValueFactory called for " + k);
                      return new Lazy<int>(() => 1);
                  },
                  (x, y) =>
                  {
                      Console.WriteLine("updateValueFactory called for " + key);
                      return new Lazy<int>(() => y.Value + 1);
                  }).Value;

public static class ConcurrentDictionaryExtensions
    {
        public static TValue GetOrAdd<TKey, TValue>(
            this ConcurrentDictionary<TKey, Lazy<TValue>> @this,
            TKey key, Func<TKey, TValue> valueFactory
        )
        {
            return @this.GetOrAdd(key,
                (k) => new Lazy<TValue>(() => valueFactory(k))
            ).Value;
        }

        public static TValue AddOrUpdate<TKey, TValue>(
            this ConcurrentDictionary<TKey, Lazy<TValue>> @this,
            TKey key, Func<TKey, TValue> addValueFactory,
            Func<TKey, TValue, TValue> updateValueFactory
        )
        {
            return @this.AddOrUpdate(key,
                (k) => new Lazy<TValue>(() => addValueFactory(k)),
                (k, currentValue) => new Lazy<TValue>(
                    () => updateValueFactory(k, currentValue.Value)
                )
            ).Value;
        }

        public static bool TryGetValue<TKey, TValue>(
            this ConcurrentDictionary<TKey, Lazy<TValue>> @this,
            TKey key, out TValue value
        )
        {
            value = default(TValue);

            var result = @this.TryGetValue(key, out Lazy<TValue> v);

            if (result) value = v.Value;

            return result;
        }

        // this overload may not make sense to use when you want to avoid
        //  the construction of the value when it isn't needed
        public static bool TryAdd<TKey, TValue>(
            this ConcurrentDictionary<TKey, Lazy<TValue>> @this,
            TKey key, TValue value
        )
        {
            return @this.TryAdd(key, new Lazy<TValue>(() => value));
        }

        public static bool TryAdd<TKey, TValue>(
            this ConcurrentDictionary<TKey, Lazy<TValue>> @this,
            TKey key, Func<TKey, TValue> valueFactory
        )
        {
            return @this.TryAdd(key,
                new Lazy<TValue>(() => valueFactory(key))
            );
        }

        public static bool TryRemove<TKey, TValue>(
            this ConcurrentDictionary<TKey, Lazy<TValue>> @this,
            TKey key, out TValue value
        )
        {
            value = default(TValue);

            if (@this.TryRemove(key, out Lazy<TValue> v))
            {
                value = v.Value;
                return true;
            }
            return false;
        }

        public static bool TryUpdate<TKey, TValue>(
            this ConcurrentDictionary<TKey, Lazy<TValue>> @this,
            TKey key, Func<TKey, TValue, TValue> updateValueFactory
        )
        {
            if (!@this.TryGetValue(key, out Lazy<TValue> existingValue))
                return false;

            return @this.TryUpdate(key,
                new Lazy<TValue>(
                    () => updateValueFactory(key, existingValue.Value)
                ),
                existingValue
            );
        }
    }

 public class LockFilter : ActionFilterAttribute
    {
        static ConcurrentDictionary<StringBuilder, int> _properties;
        static LockFilter()
        {
            _properties = new ConcurrentDictionary<StringBuilder, int>();
        }

        public  int Duration { get; set; }
        public string VaryByParam { get; set; }

        public override async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
        {
            var actionArguments = context.ActionArguments.Values.Single();
            var properties = VaryByParam.Split(",").ToList();

            StringBuilder key = new StringBuilder();
            foreach (var actionArgument in actionArguments.GetType().GetProperties())
            {
                if (!properties.Any(t => t.Trim().ToLower() == actionArgument.Name.ToLower()))
                    continue;
                var value = actionArguments.GetType().GetProperty(actionArgument.Name).GetValue(actionArguments, null).ToString();
                key.Append(value);
            }

            _properties.AddOrUpdate(key, 1, (x, y) => y + 1);

            // rest of code 
        }
    }