C#

'stuff2.somenumber' hides inherited member 'stuff1.somenumber'. Use the new keyword if hiding was intended.

OriginalGriff wrote:

Try going to your project properties, "Build" tab, and selecting "Treat warnings as error" to "All"

:::::::::   ::::::::   ::::::::  ::::    ::::  ::: 
:+:    :+: :+:    :+: :+:    :+: +:+:+: :+:+:+ :+: 
+:+    +:+ +:+    +:+ +:+    +:+ +:+ +:+:+ +:+ +:+ 
+#++:++#+  +#+    +:+ +#+    +:+ +#+  +:+  +#+ +#+ 
+#+    +#+ +#+    +#+ +#+    +#+ +#+       +#+ +#+ 
#+#    #+# #+#    #+# #+#    #+# #+#       #+#     
#########   ########   ########  ###       ### ###

OriginalGriff wrote:

I use it

BillWoodruff wrote:

why does C# let me get away with this

lmoelleb wrote:

I believe Java defaults to virtual methods

• Large repertoire of available operations, which applies to .NET 7 broadly, not only generic math. Nice operations such as rotates, popcount, leading zero count, are no longer hidden away in weird corners of the language (or worse: absent - as they used to be).
• Despite shift counts no longer needing to be int, shifting by T is not allowed. So while working with T, shifting by constants is fine (since they'd be int), but as soon as you want to shift by some value that comes out of a generic calculation.. well you still end up with some weird conversions. This also applies to the count parameter of rotates. This has anti-synergy with the return types of T.PopCount and T.TrailingZeroCount and so on, which return T. I definitely would want to write x >>> T.TrailingZeroCount(x) at some point, but no.
• There is an explicit unsigned right shift, but >> means "either signed or unsigned right shift depending on the type". What if I want an explicit signed right shift, even if T is an unsigned type? E: in non-generic code of course the answer is "just cast to the corresponding signed type, shift, then cast back". But then in generic code the question is, what type is that? See one of the next points for the problem with that.
• There is no easy way to get the number of bits in T. There are ways, sure, but I was hoping for T.BitSize or something like that. Do I really need to write T.PopCount(T.AllBitsSet)? Bonus: the result of that is a T but you probably want an int. Or x.GetByteCount() * 8 perhaps? (why do I need an instance x to find the byte count?)
• There seems to be no way to express certain constraints on types such as "given some signed type TS, TU is the corresponding unsigned type of the same size". Well, I don't know how C# would do that. But I can do it in C++, and it would be useful. For example if I wanted to define a type-changing version of Abs, which takes a signed integer and returns an unsigned integer of the same size - as it is, I wouldn't be able to constrain the types to have the same size. As far as I know, anyway.
• There are standard "low multiplications" that take two T and return the low half of the product as a T. Elsewhere in .NET classes, there are functions such as Math.BigMul that return the full product. Generic T has a lot of fancy operations defined for it, but not BigMul (nor a hypothetical HighMul that only returns the upper half of the product).