5 ms·

[SerializableAttribute] [ComVisibleAttribute(false)] public class Dictionary<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>

• louthy 12y ago
  I'm a fan of C#, although I prefer F#; however I have to agree, I think the choice of < > for generic definitions was a real mistake, it can be so hard to parse. The side effect of this is that first-class functions (Func<>) are chronically underused by C# programmers. Annoyingly F# brought them along for the ride too, although you rarely have to explicitly write them.
  • rjbwork 12y ago
    What would you have used for generic arguments? I think they work fine, and make use of Func<T> often.
    • louthy 12y ago
      I haven't tried out many alternatives, but there's something about nested <> that seems to throw me off each time. I wrote a library of monads for C# [1], and implementing the SelectMany method is a good example of how messy it can be: public static RWS<R, W, S, V> SelectMany<R, W, S, T, U, V>( this RWS<R, W, S, T> self, Func<T, RWS<R, W, S, U>> bind, Func<T, U, V> project) { } I quite like F#'s alternative syntax for single type generics: Option<int> Can be written: int option Obviously it's a personal thing, so I doubt I would be able to suggest anything that would change your mind; I just had a quick go at an alternative, and I quite like this: public static SelectMany R W S T U V ( this self : RWS R W S T, bind : Func T (RWS R W S U), project : Func T U V) : RWS R W S V { } class Thing int { } class Thing T : BaseThing T { } It's moot anyway really, it is what it is. I've just found it cognitively challenging over the years. [1] https://github.com/louthy/csharp-monad https://github.com/louthy/csharp-monad
• EpicEng 12y ago
  Given proper indentation, ifall to see what is difficult to understand here. You have acouple of attributes, a generic you're declaration (with easy to understand syntax), and an inheritance list.
  • jakevn 12y ago
    That's how it goes. A Scala dev will look at the Scala type signature and shrug. A C# dev will look at the C# type signature and shrug. As usual, unfamiliar things are difficult and familiar things are easy.
    • EpicEng 12y ago
      Yeah, and not knowing Scala myself, I can't say that the OP didn't purposely use a contrived example. That said, I still don't think a class definition which is little more than a bunch of interfaces being implemented is confusing to anyone who got through chapter 4 of "Learn C# in 21 days".
• hokkos 12y ago
  It is easier, there is only one concept to understand : generics, with scala you must understand generics, co and contra-variance, implicits.
  • jakevn 12y ago
    That's true. A talented C# dev will need to know co/contravariance as well as implicits considering they also exist in C#. In Scala, being familiar with these concepts is practically a necessity, though.
    • hokkos 12y ago
      Can you give me examples of implicits in C# ? I am unable to see a parallel.
      • jakevn 12y ago
        using System; public class Program { public class Person { private string _name; private int _age; public Person(string name, int age) { _name = name; _age = age; } public static implicit operator int(Person p) { return 42; } } public static void Main() { var person = new Person("Jim", 51); var number = 100; AdditionPrinter(person, number); // Prints 142 } public static void AdditionPrinter(int a, int b) { Console.WriteLine(a + b); } }
        • seanmcdirmid 12y ago
          Also consider extension methods, which serve some of the same purpose as implicits in Scala.
    • dragonwriter 12y ago
      > A talented C# dev will need to know co/contravariance as well as implicits considering they also exist in C#. True for co/contravariance. For implicits, that depends on which implicits you are talking about. Scala has: * implicit conversion operators (these have existed in C# for some time, under the same name) * implicit parameters (C# doesn't have an analog to these that I can think of) * implicit classes (C# has an analog in classes providing extension methods, though the classes themselves are distinguished by a keywords as they are in Scala; in Scala, these are essentially syntactic sugar for creating a normal class and an implicit conversion from the extended class.)
• deleted 12y ago
  [deleted]
• katbyte 12y ago
  Its not as hard when you format it a little nicer (and when you have syntax colouring) [SerializableAttribute] [ComVisibleAttribute(false)] public class Dictionary<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, ICollection, IReadOnlyDictionary<TKey, TValue>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, ISerializable, IDeserializationCallback { ... } And this is of course ignoring the fact you copied that from the documentation witch shows all interfaces the class implements. IDictionary also implements ICollection & IEnumerable so you wouldn't need to include them. So to actually implement this class it would more likely be [SerializableAttribute] [ComVisibleAttribute(false)] public class Dictionary<TKey, TValue> : IDictionary<TKey, TValue>, IDictionary, IReadOnlyDictionary<TKey, TValue>, ISerializable, IDeserializationCallback { ... } maybe less