I can tell from real world projects, that it works well without interfaces only having the implementing class. Following the principle “You aren’t gonna need it” (YAGNI), you simplify your code if you follow that rule. Dependency Injection works also well with classes, interfaces are not a requirement for it. Sure you can write and … Read more
public interface IPrimitive { } public interface IPrimitive<T> : IPrimitive { T Value { get; } } public class Star : IPrimitive<T> //must declare T here { } Then you should be able to have List<IPrimitive> primitives = new List<IPrimitive>; primitives.Add(new Star()); // Assuming Star implements IPrimitive primitives.Add(new Sun()); // Assuming Sun implements IPrimitive
Downside of extension methods: clients pre-C#3/VB9 won’t be able to use it as easily. That’s about it as far as I’m concerned – I think the interface-based approach is significantly nicer. You can then mock out your dependencies nicely, and everything is basically less tightly coupled. I’m not a huge fan of class inheritance unless … Read more
1.) There is a difference between method and function property declaration: interface InterfaceA { doSomething(data: object): boolean; // method declaration } interface InterfaceB { doSomething: (data: object) => boolean; // function as property declaration } 2.) TypeScript 2.6 introduces a compiler flag for stronger-typed, sound function types: Under –strictFunctionTypes function type parameter positions are checked … Read more
Using the indexer limits what can be put or fetched for the object using the index syntax. E.g. foo is inferred to be of type string: interface IDictionary { [index: string]: string; } var params = {} as IDictionary; params[‘heart’] = ‘HP’; // okay var foo = params[‘heart’]; // foo:string The following on the other … Read more
An interface isn’t a class, but you could say that both interfaces and classes are types. From the Java specification: In the Java programming language, every variable and every expression has a type that can be determined at compile-time. The type may be a primitive type or a reference type. Reference types include class types … Read more
The evils of too much coupling between services are far worse than the problems caused by code duplication The author is very unspecific when he uses the generic word “coupling”. I would agree with certain types of coupling being a strict no-no (like sharing databases or using internal interfaces). However the use of common libraries … Read more
public void Foo<T>(T myParam) where T : IObject, ITreeNode<IObject> { // whatever }
Assuming the question is about Go, e.g. var _ foo.RequiredInterface = myType{} // or &myType{} or [&]myType if scalar as a TLD will check that for you at compile time.
You can use any of these: public delegate double CustomerDelegate(int test); public interface ITest { EventHandler<EventArgs> MyHandler{get;set;} CustomerDelegate HandlerWithCustomDelegate { get; set; } event EventHandler<EventArgs> MyEvent; }