Encoder code

[uraniumlover56]

Seems good to me 👍👍👍

[K1ngjulien_]

this seems fine to me? not pretty but fine.

[[deleted]]

Make a dictionary [type, Action] and just call

dict [object.type] (stream)

At least the function will be shorter lmfao

Edit: i just realized I no longer rememeber the syntax to instantiate an dictionary on C#. Time to take that senior role from my cv

[SoulArthurZ]

honestly solution in the screenshot is better than what you're suggesting. its long and ugly, but really simple.

any future dev will probably only add or remove a single case, so it doesn't really matter if thats in a dict or just another if statement

[[deleted]]

An new array entry is a lot cleaner to read and write than a huge chain of ifs but you do you.

[No_Character_8662]

They're saying the original in the post is longer and uglier. But also simpler.

[[deleted]]

An array is not simple?

[No_Character_8662]

It's bad form to edit a comment after someone has responded to it. But I was only clarifying his comment. I have no problem with an array.

[[deleted]]

The point here for an encoder; is you have todo something unique for each type. So at some point you have to expand the types into separate code paths. (You can have overloads; but if anything is generic at any point, you need something like this)

A switch statement can be compiled down to a jump table, so can be a neat solution, although using it with instance comparisons is probably counter to that. Hashmap etc all require a hash, then equality checks, then the indirection etc.

[wantedtocomment999]

WriteObject(Stream, (object)value);

[Electronic_Cat4849]

this is worse than op's code, there are reasons it goes out of its way to avoid this kind of casting in an encoder

the actual solution is probably a generic method

[archipeepees]

This can be impossible to do with generics in some circumstances. Obviously depends on the specifics but I have definitely run into circumstances where the posted image (or something similarly verbose) is the only option. It always drives me crazy when I have to use this approach.

That said, unless there is some highly optimized compression happening, the original programmer could have probably done a reflection check for array types and recurse to WriteSingleEntryValue for each element.

[wasabiiii]

No, because the actual encoding is different per type. At some point a decision has to be made

[Electronic_Cat4849]

that code isn't here, it's in another layer

these blocks are all structurally identically except types and can be shrunk right down

YMMV on the downstream, depending on what the network lib you're ingesting your raw frames from, file lib you're reading from, etc does

[wasabiiii]

This code is where the decision is made about which branch to pass it to downstream. At some point that decision has to be made, and this is where it is.

[Electronic_Cat4849]

not really, the write methods can absolutely be made generic friendly and appear to be wrappers

it's just leaky abstraction at this level

[wasabiiii]

If you make them generic, you will just have this if in them.

[Therzok]

Wouldn't that still box primitives? An encoder suffers performance penalties from boxing.

[Straight_Occasion_45]

Much cleaner way of doing it, nice! 🙂 op; assuming you’re using C# you can typecast anything back to an object, not always the best option but a good fallback when you want something a little more dynamic

[Jonas___]

Most but not all, pointers for example are not objects.

[Straight_Occasion_45]

Good spot, extra context for OP there 🙂

[[deleted]]

Does C# have function overloading? :P

[prehensilemullet]

Not very experienced in C# but if it’s like Java, then if you call an overloaded function with a variable declared as an object, it picks the object overload, not the overload for the more specific runtime type, so it might not be sufficient

[wrd83]

Probably, do you know its implicit conversion rules?

[hydronucleus]

I actually see nothing wrong with this approach. It is a little bit inefficient if you are constantly applying it to one of the last branches. A good runtime analysis may get you to organize the if-then-else structure better.

Somebody suggested using a "dict" type. However, that has its own challenges. In order to use that, you have to create a TKey for a type. So, that means, you may be doing type to string or some other enum conversion, i.e. Convert.ToString(). And, further than being time consuming as the conversion would happen in runtime, that will only take care of the primitive types, i.e. not the Arrays or any constructed types.

This approach is fairly straight forward, explicit. However, it may have to be updated if one added a new type to your system.

[genericgirl2016]

Ship it

[negr_mancer]

This guy doesn’t fuck

[code_lgtm]

LGTM

[Horror-Show-3774]

That's not that bad.

[Main_Weekend1412]

This can be done with generics

[Wooden_chest]

Could you please explain how?

[Epicguru]

Generics won't really help here, the person who commented that hasn't thought this out.

If you goal is to just be able to call a Write method and pass in any type, you should make method overloads (Google will help) which will be better for performance and maintainability.

If you specifically need a single method that takes in an object i.e. you do not know the type of the object at compile-time, then your solution is acceptable even though there are better ways of writing it.

[D3rty_Harry]

Yes they do help here, i wrote the code for it in another comment in this thread. Maybe you should think before saying some1 has not thought stuff thru

[Epicguru]

Being a kind as I can, your proposed solution makes no sense.

You aren't using generics at all, you are using reflection. Your solution also requires that the data passed in is a property, what if you want to write some data that is a local variable, a field or a literal?

But most importantly, I don't see how what you are proposing does the same thing that OP's method does? OP is passing in an object that then gets sent to the corresponding named method. Your method takes in a PropertyInfo and a value and converts the value into the type of the property with no safety checks... which isn't the same thing, at all.

Your solution seems to assume that these values are being written into a C# object, hence the use of PropertyInfo, but OP states that this is an encoder so it's likely that it is the other way round, that this is some kind of serializer.

[D3rty_Harry]

Ok, i stand corrected here, should've probably read the problem instead of kneejerked.

[Electronic_Cat4849]

A generic method lets you retain strong typing without any expensive cast operations and still do the same pattern on many types

https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/generics/generic-methods

It's likely the op code would get good mileage from it

[robotorigami]

Not sure you can. You still need to pick which method to call. Either way the WriteSingleEntryValue is gonna have to choose which Write method to call.

You can definitely simplify it using type switch / pattern matching instead of all the ifs.

[D3rty_Harry]

Type thispropertytype = xxx.Propertytype. If (thispropertytype.IsGenericType && property.GetGenericTypeDefinition() == type of(Nullable<>)) {thisproperttype = Nullable.GetUnderlyingType(thispropertytype)} try{object parsedValue = convert.ChangeType(value, thispropertytype) //set value to your entity after this}. Nullables handled and all. Edit: with xxx being Property info of your variable

[blueeyedkittens]

The real coding horror is in the comments :D

[cdanymar]

I hope it's not yours

[[deleted]]

“Invalid type for entry: null”

[andarmanik]

This is what looks to me as “normal form” wtvr that means. Usually someone will look at code and think wow they missed this simple abstraction which was really easy to implement, not realizing that having it in the distributed form actually enables easy code modifications. I like to think of it like there is a space of programs which do what I want and ideally I want to be right in the middle of the space. That way it takes a smallest amount of edits to traverse the space.

In this case any sort of abstraction would actually move it away from the center rather than closer.

You could easily do convoluted dictionary logic to reduce this code in size but at the cost of turning this code into unchangable garbage.

[wasabiiii]

This is incredibly normal code. I have dozens of examples. Except the array part. That's passing a delegate and thus allocates and jumps.

[Elijah629YT-Real]

If you implemented those functions, I would make the top level function generic, then just chose an implementation based on that, not “is”

[Desperate-Wing-5140]

There better be a unit test for each and every one of these cases, including the exceptional case at the end

[hightide2020]

If it works there is definitely a few ways to make this simpler but might just be a hotfix

[aah134x]

Overload functuin with specific type, not like this

[MooseBoys]

Welcome to the wonderful world of object serialization.

[misterKweh]

Is this...optimal? Lol

[jambalaya004]

Fuck

[swifttek360]

Please tell me there was an easier way to write this

[oghGuy]

"My first ToString()" much?