Develop Reference

Exception when serializing polymorphic c# class with method hiding to json, ASP.NET core API

To get deep into the problem, here is a console app :
class Program
{
static void Main()
{
Console.WriteLine(JsonSerializer.Serialize(
new PolyMorphicClass { Data = new SomeData { N = 2} }));
}
class BaseClass
{
public virtual object Data { get; set; }
}
class PolyMorphicClass : BaseClass
{
public new SomeData Data { get; set; }
}
class SomeData
{
public int N { get; set; }
}
}
This code throw an invalid operation exception with this message :
The JSON property name for 'ConsoleApp_for_test.Program+PolyMorphicClass.Data' collides with another property.
I found that if I initializing BaseClass instead, like below, it works
static void Main()
{
Console.WriteLine(JsonSerializer.Serialize(
new BaseClass { Data = new SomeData { N = 2} }));
}
My actual problem is: in a WebAPI where PolymorphicClass is the response type of a controller action that is being serialized to json, and this same exception happens.
extra note: In the API I use this polymorphic behavior to make the response consistent across endpoints i.e. similar data type.
My questions are : is it ok to use the BaseClass instead of the polymorphicClass like I said above in the context of initializing API response? Is there other solutions to serialize this? Can someone explain why the exception is happening?

You can't change the return type with the new keyword, all it does is hide it and requires the use of the same signature.
You could fix this in a couple of ways.
Using Generics
Replacing object with a generic type would allow for you to define PolyMorphicClass with a specific type for Data, which I believe is similar to what you're trying to do here.
class BaseClass<T>
{
public virtual T Data { get; set; }
}
class PolyMorphicClass : BaseClass<SomeData>
{
}
Provide implementations for the property
Properties are essentially 2 methods (a getter and a setter) and you use some default ones with { get; set; }. These defaults get and set, respectively, a private member underneath the hood.
virtual properties are basically saying "You should override my getter and setter". Just specify an underlying member with the type SomeData to get and set. Here's a basic example.
class BaseClass
{
public virtual object Data { get; set; }
}
class PolyMorphicClass : BaseClass
{
private SomeData data { get; set; }
public override object Data
{
get
{
return data;
}
set
{
data = (SomeData) value;
}
}
}
Note that if you deserialize some JSON that can't be casted to SomeData you'll run into a runtime exception of System.InvalidCastException, so you may want to add some additional type checking in your setter.

Inheritance and extension of models in c# with multiple implementations of property within base

I have a pub/sub queue that returns what I'll call QueueMessages.
A QueueMessage has a Type and a Body. The type is always a string but the body varies depending on the type. I want the inheriting class to set the message type. I want to add my own local properties for storing on processing datatables.
I was hoping to be able to define a generic object for the body and override in the inheriting classes but it fails as I'm changing the return type.
Interface:
interface IBaseQueueMessage
{
Guid Id { get; set; }
string MessageType { get; }
object Message { get; set; }
DateTime ConsumeDate { get; set; }
}
Base class:
public abstract class BaseQueueMessage:IBaseQueueMessage
{
public Guid Id { get; set; }
public abstract string MessageType { get; }
public abstract object Message { get; set; }
public DateTime ConsumeDate => DateTime.Now;
}
Inheriting Classes (there are 7 or 8 different ones in total)
public sealed class Type1Message: BaseCallType
{
public override string MessageType => "Type1Message";
public override Type1Message Message { get; set; }
}
public class Type1Message
{
public string aaa { get; set; }
public int bbb { get; set; }
}
public sealed class Type2Message: BaseCallType
{
public override string MessageType => "Type2Message";
public override Type2Message Message { get; set; }
}
public class Type2Message
{
public string aaa { get; set; }
public string bbb { get; set; }
public int ccc {get; set;}
public bool ddd {get; set;}
}
The above fails as I'm trying to return a specific class instead of the generic object. I understand why it would fail, but I'd like to know what would be the correct way of doing this please? I could just define individual classes for each and to hell with the interface and inheritance but it feels wrong to approach it that way. I intend to map the QueueMessage directly onto the inheriting classes for each different type so I want the model to match exactly what I pick up from the queue.
Apologies in advance for probably missing something really obvious, it's been a while since I did any coding and this is a relatively new area to me.
Edited to add more details on implementation problem
Lots of this works, thanks. Where I still have a problem is in the MessageHandlerWrapper. If I debug, then the handler object from the constructor that the method tries to use in _handler = handler is always null.
In my .net core startup.cs I have:
void RegisterHandler<TMessageType, THandler>()
where TMessageType : class
where THandler : IMessageHandler<TMessageType>
{
serviceCollection.AddSingleton<TMessageType>();
serviceCollection.AddSingleton(
serviceProvider => new MessageHandlerWrapper<TMessageType>(serviceProvider.GetService<THandler>(), serviceProvider)
);
}
...and it's the ...=> new MessageHandlerWrapper<... near the end of that block that is resolved by the dependency when I'm debugging in the code mentioned above, so I can't see why the service isn't available at that point.
Is there some way I can manually try to debug this by resolving the service to a concrete handler in MessageHandlerWrapper to see where the problem may lie?
For completeness, the whole section in startup.cs is:
//set up message handlers
var msgFactory = new MessageHandlerFactory();
//create local function to make it easier to add service references
void RegisterHandler<TMessageType, THandler>()
where TMessageType : class
where THandler : IMessageHandler<TMessageType>
{
serviceCollection.AddSingleton<TMessageType>();
serviceCollection.AddSingleton(
serviceProvider => new MessageHandlerWrapper<TMessageType>(serviceProvider.GetService<THandler>(), serviceProvider)
);
}
// Type1MessageHandler, etc is the implementation of IMessageHandler<Type1>
RegisterHandler<Type1, Type1MessageHandler>();
RegisterHandler<Type2, Type2MessageHandler>();
RegisterHandler<Type3, Type3MessageHandler>();
RegisterHandler<Type4, Type4MessageHandler>();
// some string constants for message types would be better.
serviceCollection.AddSingleton<IMessageHandlerFactory>(serviceProvider =>
{
msgFactory.RegisterHandler("Type1",
serviceProvider.GetService<MessageHandlerWrapper<Type1>>);
msgFactory.RegisterHandler("Type2",
serviceProvider.GetService<MessageHandlerWrapper<Type2>>);
msgFactory.RegisterHandler("Type3",
serviceProvider.GetService<MessageHandlerWrapper<Type3>>);
msgFactory.RegisterHandler("Type4",
serviceProvider.GetService<MessageHandlerWrapper<Type4>>);
return msgFactory;
});
serviceCollection.AddSingleton<IMessageHandler, MessageRouter>();

Here's an approach. The intent of the design is to enable you to write type-safe generic message handler classes, but be able to call them when you're starting from a message of type object. Bridging from one to the other can be a pain, and I think it's at the heart of your question.
This doesn't use inheritance for the messages. (You mentioned you were open to not inheriting.) I don't think it would add any value in this scenario, although this could be adapted to use inheritance.
First, here's a generic Message<T> class. This doesn't replace your existing message class. It's just that in order to have a type-safe generic handler, you need a generic message.
public class Message<T>
{
public Message(T content, Guid id, string messageType, DateTime consumeDate)
{
Content = content;
Id = id;
MessageType = messageType;
ConsumeDate = consumeDate;
}
public T Content { get; }
public Guid Id { get; }
public string MessageType { get; }
public DateTime ConsumeDate { get; }
}
Next, here's an interface for a message handler. The implementation doesn't matter for this example. What matters is that whatever T is, you can write a class to handle it.
public interface IMessageHandler<T>
{
void HandleMessage(Message<T> message);
}
This next interface and class are intended to serve as a "bridge" from your non-generic message (which uses object) to your generic message handler:
public interface IMessageHandler
{
void HandleMessage(IQueueMessage message);
}
public class MessageHandlerWrapper<TMessage> : IMessageHandler
{
private readonly IMessageHandler<TMessage> _handler;
public MessageHandlerWrapper(IMessageHandler<TMessage> handler)
{
_handler = handler;
}
// This is the critical part - it gets us from object to TMessage.
public void HandleMessage(IQueueMessage message)
{
_handler.HandleMessage(
new Message<TMessage>(
(TMessage)message.Message,
message.Id,
message.MessageType,
message.ConsumeDate));
}
}
Then you'll need a factory that returns the correct IMessageHandler depending on the message type string:
public interface IMessageHandlerFactory
{
IMessageHandler GetHandler(string messageType);
}
Putting all of this together connects your non-generic message to your generic message handler:
public class MessageRouter : IMessageHandler
{
private readonly IMessageHandlerFactory _messageHandlerFactory;
public MessageRouter(IMessageHandlerFactory messageHandlerFactory)
{
_messageHandlerFactory = messageHandlerFactory;
}
public void HandleMessage(IQueueMessage message)
{
var handler = _messageHandlerFactory.GetHandler(message.MessageType);
handler.HandleMessage(message);
}
}
This class also implements IMessageHandler. It's going to take the message, without caring what the type is, use the factory to get a more specific handler, and route the message to that handler.
Now we need to implement the factory. Here's an implementation which will allow us to resolve handlers from an IServiceProvider without resorting to a service locator:
public class MessageHandlerFactory : IMessageHandlerFactory
{
private readonly Dictionary<string, Func<IMessageHandler>> _messageHandlers
= new Dictionary<string, Func<IMessageHandler>>(StringComparer.OrdinalIgnoreCase);
public void RegisterHandler(string messageType, Func<IMessageHandler> getHandlerFunction)
{
_messageHandlers[messageType] = getHandlerFunction;
}
public IMessageHandler GetHandler(string messageType)
{
if (_messageHandlers.ContainsKey(messageType))
return _messageHandlers[messageType]();
throw new InvalidOperationException($"No handler is registered for message type {messageType}.");
// Or you could return some default handler that does something else with
// unknown message types.
}
}
Now we can register implementations as follows:
public static class MessageHandlerServiceCollectionExtensions
{
public static IServiceCollection AddMessageHandlers(this IServiceCollection services)
{
void RegisterHandler<TMessageType, THandler>()
where TMessageType : class
where THandler : IMessageHandler<TMessageType>
{
services.AddSingleton<TMessageType>();
services.AddSingleton(
serviceProvider => new MessageHandlerWrapper<TMessageType>(serviceProvider.GetService<THandler>())
);
}
// MessageTypeOneHandler is the implementation of IMessageHandler<MessageTypeOne>
RegisterHandler<MessageTypeOne, MessageTypeOneHandler>();
RegisterHandler<MessageTypeTwo, MessageTypeTwoHandler>();
// some string constants for message types would be better.
services.AddSingleton<IMessageHandlerFactory>(serviceProvider =>
{
var factory = new MessageHandlerFactory();
factory.RegisterHandler("messagetypeone",
serviceProvider.GetService<MessageHandlerWrapper<MessageTypeOne>>);
factory.RegisterHandler("messagetypetwo",
serviceProvider.GetService<MessageHandlerWrapper<MessageTypeTwo>>);
return factory;
});
services.AddSingleton<IMessageHandler, MessageRouter>();
return services;
}
}
Having done all of this, does it seem a bit complex? It does to me, but I still consider it worth the effort. Why?
The message handlers are type safe instead of allowing object to propagate through the code. We're containing it like a disease. We can create simple, testable, single-responsibility classes that implement IMessageHandler<TMessage>.
Everything gets resolved from the container. That means the message handlers could all have their own unique dependencies, and that would be okay.
No reflection. It's not that reflection is evil, but once we go down that road it seems to get worse.
There is a clear path forward for the you or the next developer if you need to add handlers for more types. Even if they have no idea how to register the handlers and they don't do it, the exceptions will give them a clear path forward, showing them what they need to do. If it's registered it will get resolved. If it's not, the factory will throw an exception.
Finally, all of this is testable, even the factory. If the message types were an enum you could just run one test to ensure that there's a handler for every type.
[DataTestMethod]
[DataRow("MessageTypeOne")]
[DataRow("MessageTypeTwo")]
public void FactoryResolvesMessageHandlers(string messageType)
{
var services = new ServiceCollection();
services.AddMessageHandlers();
var provider = services.BuildServiceProvider();
var factory = provider.GetService<IMessageHandlerFactory>();
var handler = factory.GetHandler(messageType);
Assert.IsNotNull(handler);
}

Creating generic method to construct and return generic objects?

I want to create a method that will return a Response<> object and set the generic properties based on the type of the object passed in as a parameter. General code example below and additional considerations at the bottom of the post.
public class Response<T>
{
public string ResponseCode { get; get; }
public T Object { get; set;}
public List<T> Objects { get; set; }
public Response()
{
}
}
public class ChildrenResponses
{
public ChildrenResponses() // constructor
{
}
// some properties
}
public class AdultResponses
{
public AdultResponses() // constructor
{
}
// some properties
}
public Response<T> GetSpecificResponseType<T>(T genericType)
{
// ... some logic to instantiate a Response<> object using the parameter type passed into the method.
// ... some logic to set the generic properties of Response<> object based on the parameter type passed into the method.
// return object
}
I'm new to C# generics/reflection :)
Being as the Response/ChildrenResponse/AdultResponse classes existed in this code base before I began using it, I'd like to avoid changing those classes.
I've attempted multiple methods to accomplish this task, but none of them worked and providing them in this post would likely just add confusion. Instead, I provided a base method with the general idea I was working with.
An example of how I'd like to call the method:
Response<ChildrenResponses> result = GetSpecificResponseType<ChildrenResponses>("ChildrenResponses");
This method will then return the Response< ChildrenResponses > object with the Object property set to new ChildrenResponses() and Objects set to new List< ChildrenResponses >(). No properties within the ChildrenResponses need to be established - just the instantiating the object is enough.

All you need to do is restrict your generic method to require a type with a parameterless constructor. Then you should be able to do this:
public Response<T> GetSpecificResponseType<T>() where T : new()
{
return new Response<T>()
{
Object = new T(),
Objects = new List<T>()
}
}
Call like this:
Response<ChildrenResponses> result = GetSpecificResponseType<ChildrenResponses>();

I think what you are missing is an interface. It is kind of hard to tell exactly what you are trying to do, so here is the way I interpreted the question:
public class Response<T> where T: IRepsonses, new()
{
public string ResponseCode { get; set; }
public T Object { get; set; }
public List<T> Objects { get; set; }
public Response()
{
}
}
public interface IRepsonses
{
}
public class ChildrenResponses : IRepsonses
{
public ChildrenResponses() // constructor
{
}
public string ChildSays { get; set; }
// some properties
}
public class AdultResponses : IRepsonses
{
public AdultResponses() // constructor
{
}
public string AdultSays { get; set; }
// some properties
}
class Program
{
public static Response<T> GetSpecificResponseType<T>() where T: IRepsonses, new()
{
// ... some logic to instantiate a Response<> object using the parameter type passed into the method.
// ... some logic to set the generic properties of Response<> object based on the parameter type passed into the method.
// return object
T obj = new T();
return new Response<T>()
{
Object=obj,
Objects=new List<T>()
};
}
static void Main(string[] args)
{
var resp = GetSpecificResponseType<AdultResponses>();
var adult = resp.Object.AdultSays;
}
}

C# Hiding fields from model where xml deserialization points to

sI have one controller class, which is having private field of another class which is a model, model which gets data from xml deserialization. Because of this deserialization process I had to create public, parameterless constructor and some public fields-helpers which are simply processing data formats to another types. This processing is so simple that I don't want to re-write and XmlSerialization class using it's interface.
What I want to achieve is to have access to the fields from the model from the interface it inherits from only, but the model has to have public fields - how to hide some of them? They are in the same project. (Whole application is so tiny that dividing it to smaller pieces not always makes sense).
There is an example:
public class Program
{
public static void RequestHandler
{
public RequestHandler(string xmlRequest){
IRequest request = DataModel.ParseXml(xmlRequest);
//now user can use request from IRequest only
//but when he doesn't know that he has to use IRequest he can easily access and change
//values in DataModel properties, I want to prevent such possibility
}
}
}
public interface IRequest{
int test_id { get; }
DateTime description { get; }
IRequest ParseXml(string request);
bool Validate(IRequest request);
}
public class DataModel : IRequest {
[XmlElement("testId")]
int test_id { get; set; }
[XmlElement("testId")]
DateTime description { get; set; }
public DataModel() {} //this has to be specified to be allowed to use Serialization
//I don't want users to be able to use this constructor, however it has to be public
IRequest static ParseXml(string request){
// Xml Parsing process
}
bool Validate(IRequest request) {
//Process of checking if all data are available
}
}

Can you make your model as 'Internal' and expose all fields only via multiple interfaces and write another class which will expose your model objects via interface. e.g.
internal class DataModel : Interface1, Interface2 {
internal DataModel(_xml)
{
this.xml = _xml;
}
private xml {get; set;}
public Interface1.Property1 {get; set;}
public Interface2.Property2 {get; set;}
}
//expose DataModel only via below Helper class
public class DataModelHelper {
public Interface1 GetModel_1(string xml)
{
Interface1 i1 = new DataModel(xml);
return i1;
}
public Interface2 GetModel_2(xml)
{
Interface2 i2 = new DataModel(xml);
return i2;
}
}

No base class problem, How to use Castle.DynamicProxy Mixin in this particular case?

I have a 3rd party badly designed library that I must use.
It has all sorts of types it works with, we'll call them SomeType1, SomeType2 etc.
None of those types share a common base class but all have a property named Value with a different return type.
All I want to do is to be able to Mixin this class so I'll be able to call someType1Instance.Value and someType2Instance.Value without caring what the concreate type it is and without caring what the return type is (I can use object).
So my code is currently:
public interface ISomeType<V>
{
V Value {get; set;}
}
public interface ISomeTypeWrapper
{
object Value { get; set; }
}
public class SomeTypeWrapper<T> : ISomeTypeWrapper
where T : ISomeType<???>
{
T someType;
public SomeTypeWrapper(T wrappedSomeType)
{
someType = wrappedSomeType
}
public object Value
{
get { return someType.Value; }
set { someType.Value = value != null ? value : default(T); }
}
}
public class SomeType1
{
public int Value { get; set; }
}
public class SomeType2
{
public string Value { get; set; }
}
The problem is that I don't know what T might be until runtime due to the fact that I get a dictionary of objects.
I can iterate the dictionary and use reflection to create a SomeWrapperType on runtime but I would like to avoid it.
How can I mixin the concreate type of SomeType to ISomeType?
How can I know what V type parameter is? (wish I had typedefs and decltype like in c++)
How can I, with the minimum of use of reflection possible Mixin those classes with the interface/base class?

You could try the Duck Typing Extensions for Windsor. It means you will need to register each of your types.
container
.Register(Component.For(typeof(SomeType1)).Duck<ISomeType>())
.Register(Component.For(typeof(SomeType2)).Duck<ISomeType>());
You could probably use linq and the register AllTypes syntax to reduce code if the names are similar.
Alternatively in the short term create a factory which can return you the objects you need, implement a concrete object for each type. No you are using the interface you can remove the factory at a later date and replace it with something else with minimal impact:
public class SomeTypeWrapperFactory
{
public ISomeType<int> CreateWrapper(SomeType1 someType1)
{
return new SomeType1Wrapper(someType1);
}
public ISomeType<string> CreateWrapper(SomeType2 someType2)
{
return new SomeType2Wrapper(someType2);
}
}
public class SomeType1Wrapper : ISomeType<int> { ... }
public class SomeType2Wrapper : ISomeType<int> { ... }
Regardless of how you implement the wrapper, be the individually or using a god like class you have the ability to change how the wrapping is done and keep the rest of your code clean.

Why SomeTypeWrapper but not SomeObjectWrapper?
public class SomeObjectWrapper : ISomeType
{
Object _someObject;
PropertyInfo _valuePropertyInfo;
public SomeObjectWrapper(Object wrappedSomeObject)
{
_someObject = wrappedSomeObject;
_valuePropertyInfo = _someObject.GetType().GetProperty("Value", System.Reflection.BindingFlags.Public);
}
public object Value
{
get { return _valuePropertyInfo.GetValue(_someObject, null); }
set { _valuePropertyInfo.SetValue(_someObject, value, null); }
}
}

Edited With .NET 3.5 using LinFu
You may use LinFu instead of Castle. However, you would be using reflection anyway, both with Castle's and with Linfu's DynamicProxy, only hidden in the guts of the libraries instead of being exposed in your code. So if your requirement to avoid the use of reflection is out of performance concerns, you wouldn't really avoid it with this solution.
In that case I would personally choose Orsol's solution.
However: here's an example with LinFu's ducktyping.
public interface ISomeType {
object Value{get; set;}
}
public class SomeType1
{
public int Value { get; set; }
}
public class SomeType2
{
public string Value { get; set; }
}
public class SomeTypeWrapperFactory
{
public static ISomeType CreateSomeTypeWrapper(object aSomeType)
{
return aSomeType.CreateDuck<ISomeType>();
}
}
class Program
{
public static void Main(string[] args)
{
var someTypes = new object[] {
new SomeType1() {Value=1},
new SomeType2() {Value="test"}
};
foreach(var o in someTypes)
{
Console.WriteLine(SomeTypeWrapperFactory.CreateSomeTypeWrapper(o).Value);
}
Console.ReadLine();
}
}
Since you don't know the type of the SomeType's until runtime, I would not use mixins, but the visitor pattern (I know this doesn't answer the question on how to use mixins for this, but I just thought I'd throw in my 2 cents).
With .NET 4 using dynamic
See Bradley Grainger's post here on using c#4's dynamic keyword to implement the visitor pattern.
In your case, reading all the "Value" properties from your dictionary of SomeType's could work like this:
public class SomeType1
{
public int Value { get; set; }
}
public class SomeType2
{
public string Value { get; set; }
}
public class SomeTypeVisitor
{
public void VisitAll(object[] someTypes)
{
foreach(var o in someTypes) {
// this should be in a try-catch block
Console.WriteLine(((dynamic) o).Value);
}
}
}
class Program
{
public static void Main(string[] args)
{
var someTypes = new object[] {
new SomeType1() {Value=1},
new SomeType2() {Value="test"}
};
var vis = new SomeTypeVisitor();
vis.VisitAll(someTypes);
}
}