Actor serialization in the .NET SDK

Necessary steps to serialize your types using remoted Actors in .NET

The Dapr actor package enables you to use Dapr virtual actors within a .NET application with strongly-typed remoting, but if you intend to send and receive strongly-typed data from your methods, there are a few key ground rules to understand. In this guide, you will learn how to configure your classes and records so they are properly serialized and deserialized at runtime.

Data Contract Serialization

When Dapr’s virtual actors are invoked via the remoting proxy, your data is serialized using a serialization engine called the Data Contract Serializer implemented by the DataContractSerializer class, which converts your C# types to and from XML documents. When sending or receiving primitives (like strings or ints), this serialization happens transparently and there’s no requisite preparation needed on your part. However, when working with complex types such as those you create, there are some important rules to take into consideration so this process works smoothly.

This serialization framework is not specific to Dapr and is separately maintained by the .NET team within the .NET Github repository.

Serializable Types

There are several important considerations to keep in mind when using the Data Contract Serializer:

  • By default, all types, read/write properties (after construction) and fields marked as publicly visible are serialized
  • All types must either expose a public parameterless constructor or be decorated with the DataContractAttribute attribute
  • Init-only setters are only supported with the use of the DataContractAttribute attribute
  • Read-only fields, properties without a Get and Set method and internal or properties with private Get and Set methods are ignored during serialization
  • Serialization is supported for types that use other complex types that are not themselves marked with the DataContractAttribute attribute through the use of the KnownTypesAttribute attribute
  • If a type is marked with the DataContractAttribute attribute, all members you wish to serialize and deserialize must be decorated with the DataMemberAttribute attribute as well or they’ll be set to their default values

How does deserialization work?

The approach used for deserialization depends on whether or not the type is decorated with the DataContractAttribute attribute. If this attribute isn’t present, an instance of the type is created using the parameterless constructor. Each of the properties and fields are then mapped into the type using their respective setters and the instance is returned to the caller.

If the type is marked with [DataContract], the serializer instead uses reflection to read the metadata of the type and determine which properties or fields should be included based on whether or not they’re marked with the DataMemberAttribute attribute as it’s performed on an opt-in basis. It then allocates an uninitialized object in memory (avoiding the use of any constructors, parameterless or not) and then sets the value directly on each mapped property or field, even if private or uses init-only setters. Serialization callbacks are invoked as applicable throughout this process and then the object is returned to the caller.

Use of the serialization attributes is highly recommended as they grant more flexibility to override names and namespaces and generally use more of the modern C# functionality. While the default serializer can be relied on for primitive types, it’s not recommended for any of your own types, whether they be classes, structs or records. It’s recommended that if you decorate a type with the DataContractAttribute attribute, you also explicitly decorate each of the members you want to serialize or deserialize with the DataMemberAttribute attribute as well.

.NET Classes

Classes are fully supported in the Data Contract Serializer provided that that other rules detailed on this page and the Data Contract Serializer documentation are also followed.

The most important thing to remember here is that you must either have a public parameterless constructor or you must decorate it with the appropriate attributes. Let’s review some examples to really clarify what will and won’t work.

In the following example, we present a simple class named Doodad. We don’t provide an explicit constructor here, so the compiler will provide an default parameterless constructor. Because we’re using supported primitive types (Guid, string and int32) and all our members have a public getter and setter, no attributes are required and we’ll be able to use this class without issue when sending and receiving it from a Dapr actor method.

  1. public class Doodad
  2. {
  3. public Guid Id { get; set; }
  4. public string Name { get; set; }
  5. public int Count { get; set; }
  6. }

By default, this will serialize using the names of the members as used in the type and whatever values it was instantiated with:

  1. <Doodad>
  2. <Id>a06ced64-4f42-48ad-84dd-46ae6a7e333d</Id>
  3. <Name>DoodadName</Name>
  4. <Count>5</Count>
  5. </Doodad>

So let’s tweak it - let’s add our own constructor and only use init-only setters on the members. This will fail to serialize and deserialize not because of the use of the init-only setters, but because there’s no parameterless constructors.

  1. // WILL NOT SERIALIZE PROPERLY!
  2. public class Doodad
  3. {
  4. public Doodad(string name, int count)
  5. {
  6. Id = Guid.NewGuid();
  7. Name = name;
  8. Count = count;
  9. }
  10. public Guid Id { get; set; }
  11. public string Name { get; init; }
  12. public int Count { get; init; }
  13. }

If we add a public parameterless constructor to the type, we’re good to go and this will work without further annotations.

  1. public class Doodad
  2. {
  3. public Doodad()
  4. {
  5. }
  6. public Doodad(string name, int count)
  7. {
  8. Id = Guid.NewGuid();
  9. Name = name;
  10. Count = count;
  11. }
  12. public Guid Id { get; set; }
  13. public string Name { get; set; }
  14. public int Count { get; set; }
  15. }

But what if we don’t want to add this constructor? Perhaps you don’t want your developers to accidentally create an instance of this Doodad using an unintended constructor. That’s where the more flexible attributes are useful. If you decorate your type with a DataContractAttribute attribute, you can drop your parameterless constructor and it will work once again.

  1. [DataContract]
  2. public class Doodad
  3. {
  4. public Doodad(string name, int count)
  5. {
  6. Id = Guid.NewGuid();
  7. Name = name;
  8. Count = count;
  9. }
  10. public Guid Id { get; set; }
  11. public string Name { get; set; }
  12. public int Count { get; set; }
  13. }

In the above example, we don’t need to also use the DataMemberAttribute attributes because again, we’re using built-in primitives that the serializer supports. But, we do get more flexibility if we use the attributes. From the DataContractAttribute attribute, we can specify our own XML namespace with the Namespace argument and, via the Name argument, change the name of the type as used when serialized into the XML document.

It’s a recommended practice to append the DataContractAttribute attribute to the type and the DataMemberAttribute attributes to all the members you want to serialize anyway - if they’re not necessary and you’re not changing the default values, they’ll just be ignored, but they give you a mechanism to opt into serializing members that wouldn’t otherwise have been included such as those marked as private or that are themselves complex types or collections.

Note that if you do opt into serializing your private members, their values will be serialized into plain text - they can very well be viewed, intercepted and potentially manipulated based on how you’re handing the data once serialized, so it’s an important consideration whether you want to mark these members or not in your use case.

In the following example, we’ll look at using the attributes to change the serialized names of some of the members as well as introduce the IgnoreDataMemberAttribute attribute. As the name indicates, this tells the serializer to skip this property even though it’d be otherwise eligible to serialize. Further, because I’m decorating the type with the DataContractAttribute attribute, it means that I can use init-only setters on the properties.

  1. [DataContract(Name="Doodad")]
  2. public class Doodad
  3. {
  4. public Doodad(string name = "MyDoodad", int count = 5)
  5. {
  6. Id = Guid.NewGuid();
  7. Name = name;
  8. Count = count;
  9. }
  10. [DataMember(Name = "id")]
  11. public Guid Id { get; init; }
  12. [IgnoreDataMember]
  13. public string Name { get; init; }
  14. [DataMember]
  15. public int Count { get; init; }
  16. }

When this is serialized, because we’re changing the names of the serialized members, we can expect a new instance of Doodad using the default values this to be serialized as:

  1. <Doodad>
  2. <id>a06ced64-4f42-48ad-84dd-46ae6a7e333d</id>
  3. <Count>5</Count>
  4. </Doodad>

Classes in C# 12 - Primary Constructors

C# 12 brought us primary constructors on classes. Use of a primary constructor means the compiler will be prevented from creating the default implicit parameterless constructor. While a primary constructor on a class doesn’t generate any public properties, it does mean that if you pass this primary constructor any arguments or have non-primitive types in your class, you’ll either need to specify your own parameterless constructor or use the serialization attributes.

Here’s an example where we’re using the primary constructor to inject an ILogger to a field and add our own parameterless constructor without the need for any attributes.

  1. public class Doodad(ILogger<Doodad> _logger)
  2. {
  3. public Doodad() {} //Our parameterless constructor
  4. public Doodad(string name, int count)
  5. {
  6. Id = Guid.NewGuid();
  7. Name = name;
  8. Count = count;
  9. }
  10. public Guid Id { get; set; }
  11. public string Name { get; set; }
  12. public int Count { get; set; }
  13. }

And using our serialization attributes (again, opting for init-only setters since we’re using the serialization attributes):

  1. [DataContract]
  2. public class Doodad(ILogger<Doodad> _logger)
  3. {
  4. public Doodad(string name, int count)
  5. {
  6. Id = Guid.NewGuid();
  7. Name = name;
  8. Count = count;
  9. }
  10. [DataMember]
  11. public Guid Id { get; init; }
  12. [DataMember]
  13. public string Name { get; init; }
  14. [DataMember]
  15. public int Count { get; init; }
  16. }

.NET Structs

Structs are supported by the Data Contract serializer provided that they are marked with the DataContractAttribute attribute and the members you wish to serialize are marked with the DataMemberAttribute attribute. Further, to support deserialization, the struct will also need to have a parameterless constructor. This works even if you define your own parameterless constructor as enabled in C# 10.

  1. [DataContract]
  2. public struct Doodad
  3. {
  4. [DataMember]
  5. public int Count { get; set; }
  6. }

.NET Records

Records were introduced in C# 9 and follow precisely the same rules as classes when it comes to serialization. We recommend that you should decorate all your records with the DataContractAttribute attribute and members you wish to serialize with DataMemberAttribute attributes so you don’t experience any deserialization issues using this or other newer C# functionalities. Because record classes use init-only setters for properties by default and encourage the use of the primary constructor, applying these attributes to your types ensures that the serializer can properly otherwise accommodate your types as-is.

Typically records are presented as a simple one-line statement using the new primary constructor concept:

  1. public record Doodad(Guid Id, string Name, int Count);

This will throw an error encouraging the use of the serialization attributes as soon as you use it in a Dapr actor method invocation because there’s no parameterless constructor available nor is it decorated with the aforementioned attributes.

Here we add an explicit parameterless constructor and it won’t throw an error, but none of the values will be set during deserialization since they’re created with init-only setters. Because this doesn’t use the DataContractAttribute attribute or the DataMemberAttribute attribute on any members, the serializer will be unable to map the target members correctly during deserialization.

  1. public record Doodad(Guid Id, string Name, int Count)
  2. {
  3. public Doodad() {}
  4. }

This approach does without the additional constructor and instead relies on the serialization attributes. Because we mark the type with the DataContractAttribute attribute and decorate each member with its own DataMemberAttribute attribute, the serialization engine will be able to map from the XML document to our type without issue.

  1. [DataContract]
  2. public record Doodad(
  3. [property: DataMember] Guid Id,
  4. [property: DataMember] string Name,
  5. [property: DataMember] int Count)

Supported Primitive Types

There are several types built into .NET that are considered primitive and eligible for serialization without additional effort on the part of the developer:

There are additional types that aren’t actually primitives but have similar built-in support:

Again, if you want to pass these types around via your actor methods, no additional consideration is necessary as they’ll be serialized and deserialized without issue. Further, types that are themselves marked with the (SerializeableAttribute)[https://learn.microsoft.com/en-us/dotnet/api/system.serializableattribute\] attribute will be serialized.

Enumeration Types

Enumerations, including flag enumerations are serializable if appropriately marked. The enum members you wish to be serialized must be marked with the EnumMemberAttribute attribute in order to be serialized. Passing a custom value into the optional Value argument on this attribute will allow you to specify the value used for the member in the serialized document instead of having the serializer derive it from the name of the member.

The enum type does not require that the type be decorated with the DataContractAttribute attribute - only that the members you wish to serialize be decorated with the EnumMemberAttribute attributes.

  1. public enum Colors
  2. {
  3. [EnumMember]
  4. Red,
  5. [EnumMember(Value="g")]
  6. Green,
  7. Blue, //Even if used by a type, this value will not be serialized as it's not decorated with the EnumMember attribute
  8. }

Collection Types

With regards to the data contact serializer, all collection types that implement the IEnumerable interface including arays and generic collections are considered collections. Those types that implement IDictionary or the generic IDictionary<TKey, TValue> are considered dictionary collections; all others are list collections.

Not unlike other complex types, collection types must have a parameterless constructor available. Further, they must also have a method called Add so they can be properly serialized and deserialized. The types used by these collection types must themselves be marked with the DataContractAttribute attribute or otherwise be serializable as described throughout this document.

Data Contract Versioning

As the data contract serializer is only used in Dapr with respect to serializing the values in the .NET SDK to and from the Dapr actor instances via the proxy methods, there’s little need to consider versioning of data contracts as the data isn’t being persisted between application versions using the same serializer. For those interested in learning more about data contract versioning visit here.

Known Types

Nesting your own complex types is easily accommodated by marking each of the types with the DataContractAttribute attribute. This informs the serializer as to how deserialization should be performed. But what if you’re working with polymorphic types and one of your members is a base class or interface with derived classes or other implementations? Here, you’ll use the KnownTypeAttribute attribute to give a hint to the serializer about how to proceed.

When you apply the KnownTypeAttribute attribute to a type, you are informing the data contract serializer about what subtypes it might encounter allowing it to properly handle the serialization and deserialization of these types, even when the actual type at runtime is different from the declared type.

  1. [DataContract]
  2. [KnownType(typeof(DerivedClass))]
  3. public class BaseClass
  4. {
  5. //Members of the base class
  6. }
  7. [DataContract]
  8. public class DerivedClass : BaseClass
  9. {
  10. //Additional members of the derived class
  11. }

In this example, the BaseClass is marked with [KnownType(typeof(DerivedClass))] which tells the data contract serializer that DerivedClass is a possible implementation of BaseClass that it may need to serialize or deserialize. Without this attribute, the serialize would not be aware of the DerivedClass when it encounters an instance of BaseClass that is actually of type DerivedClass and this could lead to a serialization exception because the serializer would not know how to handle the derived type. By specifying all possible derived types as known types, you ensure that the serializer can process the type and its members correctly.

For more information and examples about using [KnownType], please refer to the official documentation.