Extension Methods

Creating extension methods for third-party NuGet packages, rather than calling them directly, can provide several benefits and maintain better coding practices.

Here’s why this approach is often recommended:

1. Abstraction and Encapsulation

By wrapping third-party functionality in extension methods, you abstract and encapsulate the details of the third-party library. This makes your code cleaner and easier to maintain.

2. Consistency

If you need to use the same third-party method in multiple places, using an extension method ensures consistency. You don't have to repeat the same logic everywhere; instead, you just call your extension method.

3. Error Handling

You can centralize error handling in your extension methods. If the third-party method throws an exception, you can catch it and handle it in a consistent manner across your application.

4. Flexibility

By using extension methods, you can easily swap out the third-party library with another one if needed. You only need to update your extension methods without affecting the rest of your codebase.

5. Testability

Extension methods can help isolate third-party code, making it easier to mock and test your application. This is particularly useful for unit testing.

6. Readability and Reusability

Extension methods can make your code more readable and reusable. They allow you to add functionality to existing types without modifying their source code or using inheritance.

Example

Here are the extension methods you provided, which encapsulate third-party functionality (e.g., Newtonsoft.Json):

public static class StringExtensions
{
    public static T ToEnum<T>(this string value) where T : Enum
    {
        try
        {
            return (T)Enum.Parse(typeof(T), value, true);
        }
        catch
        {
            return (T)Enum.ToObject(typeof(T), 0);
        }
    }

    public static T? ToObject<T>(this string? jsonStr)
    {
        try
        {
            if (jsonStr != null)
            {
                var obj = JsonConvert.DeserializeObject<T>(jsonStr,
                    new JsonSerializerSettings { DateParseHandling = DateParseHandling.DateTimeOffset });
                return obj;
            }
        }
        catch
        {
            return (T)Convert.ChangeType(jsonStr, typeof(T))!;
        }

        return default;
    }

    public static string? ToJson<T>(this T? obj, bool format = false)
    {
        if (obj == null) return string.Empty;
        string? result;
        if (obj is string)
        {
            result = obj.ToString();
            goto Result;
        }

        var settings = new JsonSerializerSettings { DateFormatString = "yyyy-MM-ddTHH:mm:ss.sssZ" };
        result = format
            ? JsonConvert.SerializeObject(obj, Newtonsoft.Json.Formatting.Indented, settings)
            : JsonConvert.SerializeObject(obj, settings);
        Result:
        return result;
    }

    public static JObject ToJObject(this object? obj)
    {
        return JObject.FromObject(obj);
    }
}

Usage

You can use these extension methods in your code like this:

string jsonString = "{ \"name\": \"John\", \"age\": 30 }";
var person = jsonString.ToObject<Person>();
string enumString = "Active";
StatusEnum status = enumString.ToEnum<StatusEnum>();
string json = person.ToJson(true);
JObject jObject = person.ToJObject();

By using extension methods, you improve the maintainability, readability, and flexibility of your code.