How to restrict derived class to only have members of certain types

Question

I need to enforce the members of a class derived from a base class to only have a certain type.

For example if I have a MustInherit Class Serializable which has a method ToByteArray(). How can I restrict derived classes to only have fields which are specific types (for example restricted to having fields of type int, char or byte) so that I'm guaranteed to be able to serialize the class with the ToByteArray method which I have written.

The reason for this is because I want any derived classes to have a constant byte representation when it is serialized.

For example:

class Foo
    Inherits Serializable

'Valid field as it is a char guaranteed to be two bytes
Public field1 As Char

'Valid field as it is a Int which is guaranteed to be two bytes
Public field2 As Integer

'**Invalid as a string can be a dynamic length which is not wanted in this context
Public field3 As String 
End Class

Is this restriction possible in .net? vb.net in specific however I'm familiar with both and can convert between the two.

An idea I had was to throw a run-time error in the class Serializable's constructor after looping through the fields using Reflection and comparing their types against a list of valid types. However this a is a weak solution as an invalid class would only be detected during run-time, rather than compile time.

Here is a SO question which tackles the same problem but is in C++ not C# (just for guidance as to the desired behavior if needed) How to enforce derived class members on derived classes

Update 9/2/2020 now that I've learned Unit Tests: Quite a simple solution is to use Reflection in a UnitTest

<TestMethod()>
Public Sub ShouldObeyTypeConstraintsTest()
    Dim types As IEnumerable(Of Type) = From t In Assembly.GetAssembly(GetType(IRestricted)).GetTypes() 
                        From i In t.GetInterfaces() 
                        Where i.IsGenericType AndAlso (i.GetGenericTypeDefinition() Is GetType(IRestricted(Of ))) 
                        Select t

    For Each type As Type In types
        Dim info() As FieldInfo = serializable.GetFields()

        For Each field In info
            Dim fieldType As Type = field.FieldType()
            If Not isValidType(fieldType) Then
                Assert.Fail($"IRestricted type {serializable.FullName} has invalid field {fieldType.Name}")
            End If
        Next
    Next
End Sub

Answer 1

You can use several override methods with the types you want to set the value of the MyField just by one of them.

In this way you can be sure the MyField type is one of your specified types.

using System;

public class Program
{
    public static void Main()
    {
        var b = new Book();
        b.SetMyField(1);
        Console.WriteLine(b.MyField);
        b.SetMyField('A');
        Console.WriteLine(b.MyField);
    }
}


public interface IMySerializable {
    object MyField { get; }
    void SetMyField( int val);
    void SetMyField( char val);
    void SetMyField( byte val);
}

public class Book : IMySerializable {

    public object MyField { 
        get; 
        private set;
    }

    public void SetMyField( int val){
        MyField=val;
    }

    public void SetMyField( char val){
        MyField=val;
    }

    public void SetMyField( byte val){
        MyField=val;
    }
}

Unfortunately you can not specify some types like int, char in the where condition of a generic class or method in C# else you get an error like this:

---

Also try using the ISerializable interface. Here there is an article about it.

Answer 2

No, what you're describing is not possible. There is no compile-time constraint you can place on a class that dictates what types of members it can have.

If you're going to implement this custom ToByteArray method, one solution would be to use attributes that indicate which members are or are not serialized. There's already an attribute for that to determine which fields are included in binary serialization. That's the NonSerializedAttribute.

In your ToByteArray() method, as you're reflecting the various fields, you would check each one to see if it has the attribute, and ignore it if it does. (I'm assuming that you're using reflection, because otherwise the method would specify which fields to include, and the problem wouldn't exist.)

If you're going to use the existing attribute, you might want to just consider using existing binary serialization instead of writing your own ToByteArray method. You can use the BinaryFormatter class. Then you can use the same attribute to prevent serializing certain fields.

What none of this gets you is compile-time certainty that the type can actually be serialized. Because serialization will involve types (not logic that depends on particular values) any serialization issues would appear as you test. You could even write unit tests that create and serialize instances of each class and that would prevent runtime errors.