How to extend existing third party model?

Question

I have a third party library i am using. The have provided some of the classes for me to use to transfer data from one page to another, but i dont have the source code to make changes, for example

public class Customer
{
public string Name {get;set}
public Additional AdditionalDetails {get;set}
}

In this example i want to extend the Additional class and add properties to it without breaking the existing workings.

My controller and view works by passing in the customer class but all i want to do is add a new property to the Additional class.

I have tried to create a partial class but that didnt work and received the warning partial class with single part.

I then tried to create the class as

public class Additional

under the same namespace in my project and add the new property but that too didnt work (property didnt show).

Is there a way for me to extend this Additional class without breaking the existing code?

Answer 1

Is there a way for me to extend this Additional class without breaking the existing code?

In order extend the Additional class and add properties to it without breaking the existing workings, we could follow couple of approach, one of the way could be Wrapper Class

This approach allows you to keep using the existing third-party class (Customer and Additional) without any modifications to their usage while adding new properties to Additional.

First of all, I would be creating a customer with existing details, then need to Wrap the AdditionalDetails where would would inlcude the new proeprty and finally would build view model to pass the data to the view.

Let's have a look in practice:

Existing Class:

public class Additional
{
    public string ExistingProperty { get; set; }
}


public class Customer
{
    public string Name { get; set; }
    public Additional AdditionalDetails { get; set; }
}


public interface IAdditional
{
    string ExistingProperty { get; }
}

Wrapper Class:

public class ExtendedAdditional : IAdditional
{
    private readonly Additional _original;

    public ExtendedAdditional(Additional original)
    {
        _original = original ?? throw new ArgumentNullException(nameof(original));
    }

    public string ExistingProperty => _original.ExistingProperty;

    public string NewProperty { get; set; }
}

View Model:

public class CustomerViewModel
{
    public Customer Customer { get; set; }
    public ExtendedAdditional ExtendedAdditional { get; set; }
}

Controller:

public IActionResult Index()
 {
     
     var customer = new Customer
     {
         Name = "Kiron Test",
         AdditionalDetails = new Additional { ExistingProperty = "Existing Value" }
     };

    
     var extendedAdditional = new ExtendedAdditional(customer.AdditionalDetails)
     {
         NewProperty = "New Value"
     };

     
     var model = new CustomerViewModel
     {
         Customer = customer,
         ExtendedAdditional = extendedAdditional
     };

     return View(model);
 }

View:

@model CustomerViewModel

<h2>Customer Details</h2>
<p>Name: @Model.Customer.Name</p>

<h3>Additional Details</h3>
<p>Existing Property: @Model.ExtendedAdditional.ExistingProperty</p>
<p>New Property: @Model.ExtendedAdditional.NewProperty</p>

Output:

Note: In most cases, using a wrapper class (ExtendedAdditional) is considered more elegant and aligns better with principles of object-oriented design and separation of concerns. It provides a clear boundary between your application's logic and the third-party library's implementation.

Answer 2

You can create a new class that contains an instance of the Additional class and adds the extra properties you need. This way, you avoid modifying the existing class directly.

public class AdditionalExtended
{
    public Additional AdditionalDetails { get; set; }
    public string NewProperty { get; set; }
}

Then, update your Customer class to use the AdditionalExtended class:

public class Customer
{
    public string Name { get; set; }
    public AdditionalExtended AdditionalDetailsExtended { get; set; }
}

You will need to update your code to use the AdditionalDetailsExtended property instead of the AdditionalDetails property.

Answer 3

At the time of writing this is still in preview, but in C# 13 you will have a new feature called "Extensions" which allows you to extend any class even from 3rd parties.

So you can do the following:

    public implicit extension AdditionalExtention for Additional
    {    
        //Extend property example 
        public string FullName { get => $"{this.Firstname} {this.Surname}"; }

        //Simple example of extension method getting an approximate age
        public int GetAge(this Additional additional)
        {
            return DateTime.Today.Year - this.DateOfBirth.Year;
        }
    }

Then you just use your class as normal.

    var age = customer.GetAge();
    var fullname = customer.Fullname;

Nick Chapsas explains the feature much better than I can in his video. https://www.youtube.com/watch?v=ueO5Cb3Emcw