C# Interfaces With Default Method Implementations #shorts

[jose-sebastian-garcia]

I don't like it :/ default implementations in classes ok, but interfaces? why?

So, the main objective with the interfaces is that they are used as an abstract layer devoid of functionality, since there are abstract classes for that.

[antonmartyniuk]

The real use case: you need to add some minor functionality (a new interface method) but you don't wanna your clients to change the code. You just replace dll with abstractions with a new one and the app doesn't break

[nothingisreal]

I used it. But granted: there are abstract classes that serve the same purpose.

[SelmirAljic]

I’m not sure if it’s possible to use like this, but when you provide a public api library where you want to stay backwards compatible, but still want to rename a method on an interface you can make it call the old implementation and make the old implementation obsolete so that users can slowly switch to the new version

[nage]

it is literally traits, so yea there are cases to use

[johnjacobjingleheimerschmi]

We learned interfaces after I already finished my project last year and they would have been soooo good for it

[kazepis]

I had used this in the past in an interesting case of a user repository interface with two implementations one of which was a distributed one using redis and required distributed locking. To avoid code duplication I moved the implementation to the interface and the redis implementation surrounded it with a distributed lock while the non redis one used the default from the interface.

[PatricSjoeoe]

I use this when I have methods with overloads and default values to redirect to correct implemented method.

[omarattia-nj]

and how about multiple interfaces? isn't that why interfaces was interduced the first time?

[lettuceturnipthebeets]

the only use case I've stumbled upon with default implementation of interface members was not really in production, but could be interesting

it was one way to implement the state pattern, where the default behaviour of IState interface would be doing nothing, so when the object is not in the right state nothing happens on triggering it

it could be done with inheritance and virtual members, but default interface implementation allows you to not use override keyword, and I'm always happy to write less code :)

[johnnyjosep]

I used to declare the basic behavior of "IMapFrom" in AutoMapper.

[LiquaFoo]

Ask the Java guys they’ve had this for a while now

[ronaldmarrou]

This is like the Family Guys meme "what the hell is this?" where the combination of abstract classes and an actual interface combines into this.

Seriously, I would not use it unless there is proven useful. In the mean time, Abstracts do the job quite well.

[vittoriomorellini]

Why us3 an interface and not an abstract class? What is the worth to use interface with implementation?