[Proposal] C# Feature Support Dynamic base class functionality

[wangronghua]

Dynamic base class functionality

For example, there is now a base class library called BaseAssembly that includes the base classes Animal and Plant. As they are intended for use in multiple projects, these two base classes are generic and cannot be changed arbitrarily.

In Project A, there are types Tiger and Elephant that inherit from Animal, and types Apple and Banana that inherit from Plant. Currently, some common properties and methods based on the current project are universal to Animal and Plant and are encapsulated in the type ProjectAOrganism

public class ProjectAOrganism
{
	public Task Method1()
	{
		...
	}
	public Task Method2()
	{
		...
	}
	public string Property1
	{
		get{
			...
		}
		set{
			...
		}
	}
	public string Property2
	{
		get{
			...
		}
		set{
			...
		}
	}
}

The current issue is that Tiger and Elephant not only inherit Animal but also ProjectAOrganism, while Apple and Banana not only inherit Plant but also ProjectAOrganism. Because ProjectAOrganism is strongly related to Project A, it should not be written in the base class library BaseAssembly as the base class for Animal and Plant.

The only method that comes to mind now is this:

Write two duplicate copies of ProjectAOrganismAnimal and ProjectAOrganismPlant for ProjectAOrganism,

The inheritance relationship is as follows

Tiger, Elephant=>ProjectAOrganismAnimal=>Animal

Apple, Banana=>ProjectAOrganismPlant=>Plant

The disadvantage is that two copies of the same code need to be written, and if there are other base classes that need to be used with ProjectAOrganism, another copy needs to be written, which is very redundant. Although methods can solve the redundancy problem through extension methods, it seems that there is no extension method for attributes, and they can only be implemented through redundancy as mentioned here.

If there is the following dynamic inheritance function, it can perfectly solve this problem

public class ProjectAOrganism<T>:T
{
	public Task Method1()
	{
		...
	}
	public Task Method2()
	{
		...
	}
	public string Property1
	{
		get{
			...
		}
		set{
			...
		}
	}
	public string Property2
	{
		get{
			...
		}
		set{
			...
		}
	}
}

public class Tiger : ProjectAOrganism<Animal> //will automatically inherit Animal
{}
public class Elephant : ProjectAOrganism<Animal> //will automatically inherit Animal
{}
public class Apple : ProjectAOrganism<Plant> //will automatically inherit Plant
{}
public class Banana : ProjectAOrganism<Plant> //will automatically inherit Plant
{}

[huoyaoyuan]

This can be covered by the interface-implementing extension feature. It will allow you to "attach" interface implementation to types from other assembly. Then you can add a common interface for those types. See #7928.

[huoyaoyuan]

In fact, the implementation code for these two methods and two properties in the animal and plant subclasses is exactly the same.

Do you mean that you want to "attach" a same set of members to two different families of types?

You can use extension to attach implementations of a same interface to the base types Animal and Plant, then use another extension, or traditional extension methods to attach the methods to the interface.

It's not a perfect solution though. Actually changing the types defined by others is highly impossible for the whole CLR and other tooling.

[wangronghua]

Thank you for your answer. Extension methods can only implement function extensions, and properties cannot be extended

interface IProjectAOrganism
{
}
public class Tiger : Animal,IProjectAOrganism
{}
public class Elephant : Animal,IProjectAOrganism
{}
public class Apple : Plant,IProjectAOrganism
{}
public class Banana : Plant,IProjectAOrganism
{}

public static class Extentions
{
    public static async Task Method1(this IProjectAOrganism) { await something; }
    public static async Task Method2(this IProjectAOrganism) { await something; }
	//Property1、Property2 cann't support
}

[huoyaoyuan]

Extension methods can only implement function extensions, and properties cannot be extended

The proposed extension feature is going to allow properties. See https://github.com/dotnet/csharplang/blob/main/proposals/extensions.md#properties .

Supporting stateful members (new fields, or auto properties) is a hard problem, or maybe impossible.

[wangronghua]

Yes, Supporting stateful members (new fields, or auto properties) is a hard problem or possibly impossible. If dynamic inheritance is implemented, there is no such problem, and it can be divided into multiple layers based on business purposes, solving the problem that classes in c # cannot inherit multiple classes

public abstract class ProjectAOrganism1<T>:T
{
	public Task Method1()
	{
		...
	}
	public string Property1
	{
		get{
			...
		}
		set{
			...
		}
	}
	...
}
public abstract class ProjectAOrganism2<T>:ProjectAOrganism1<T>
{
	public Task Method2()
	{
		...
	}
	public string Property2
	{
		get{
			...
		}
		set{
			...
		}
	}
	...
}

public class Tiger : ProjectAOrganism2<Animal> //will automatically inherit Animal and has Method1、Method2、Property1、Property2
{}
public class Elephant : ProjectAOrganism1<Animal> //will automatically inherit Animal and has Method1、Property1
{}
public class Apple : ProjectAOrganism1<Plant> //will automatically inherit Plant and has Method1、Property1
{}
public class Banana : ProjectAOrganism2<Plant> //will automatically inherit Plant and has Method1、Method2、Property1、Property2
{}

[huoyaoyuan]

If dynamic inheritance is implemented

It is as hard as, or even harder than attaching instance state. It's challenging for how types are loaded totally.