
.NET Core gRPC - ingve
https://grpc.io/blog/grpc-on-dotnetcore/
======
nevi-me
This is great for people heavily invested in the .NET world. I like the
integration with VS, and with the language overall.

We worked with a small vendor on a project at work last year, where he was
building a frontend for our gRPC based backend system. My team inherited him
from another division that was winding down, and though he had weird choices
of tooling and frameworks, we couldn't dictate what he used as that was out of
our control.

What we imposed though was that he only use gRPC to communicate with our
services. He struggled a lot, I spent about an hour with him trying to compile
the proto files. He also weirdly converted every message to JSON then XML. I
assumed he'd been used to covering from JSON to XML. In the end, we had a poor
experience and decided to rebuild the thing in-house.

My observations were that other than unfamiliarity with gRPC, he knows his way
around MS stuff, the lack of seamless integration with his technology stack.

This integration should make it easier for people to get productive faster,
and for new users to experiment.

------
jve
If webmaster is here - please don't make us read this with a (magifying
glass). Luckily browsers have zoom.

~~~
cc81
I wonder if that is a mistake. All other pages have a decent text size and for
some reason when you click in on individual blog pages they are set with a
font-size of 0.6 rem.

------
Ciantic
I will note that exciting part for me is that the code generation is triggered
by having single line in project file:

<ItemGroup><Protobuf Include="Protos\greet.proto" /></ItemGroup>

Also the code generated goes to obj directory so it's not versioned. I think
this is nice way to do code generation, and sidesteps some of the need for
type providers in the future for C#.

------
ToFab123
Is this a replacement or a supplement/alternative to WCF?

~~~
algorithmsRcool
Short answer is yes for most workloads. It's fast, scalable and well
supported.

WCF could operate over pipes which was cool for machine local IPC, but beyond
that I think gRPC is superior.

But I asked your exact question to the dotnet team and architect David Fowler
gave me a decent answer.

> "I don't know that we have a definitive answer as yet and the GRPC
> experience while great isn't nearly as smooth (as of writing) as the WCF
> experience. I would say that it's definitely going to be one of the main RPC
> option of choice going forward but it;s a bit early to say that this is THE
> blessed new way."

[https://github.com/dotnet/core/issues/2278](https://github.com/dotnet/core/issues/2278)

~~~
paulio
I might be the only person who liked WCF.

~~~
algorithmsRcool
I liked kinda liked it, but trying to unify HTTP, TCP, Pipes and MSMQ into a
single framework was probably overly ambitious. WCF always felt very
complicated with all sorts of sharp edges to me.

~~~
WorldMaker
WCF also originally supported peer-to-peer network topologies, discovery
methods like PNRP (Microsoft's competitor standard to eventual "winner"
Bonjour/mDNS), various versions of the SOAP metadata formats, and WS-*
standards, etc.

It was definitely ambitious. When it worked it was sometimes magic, and when
it didn't it was a giant mess to resolve.

[ETA: In one past life I made the mistake of trying to use WCF Peer-to-Peer
for a project and I still have scars from that. :O]

------
polskibus
Why is it net core 3.0 only ? What prevented the authors from targeting lower
net core versions or netstandard2 ?

~~~
SideburnsOfDoom
I expect that it uses Pipelines ( * ) which is a new high-performance design
using Span<T> and related classes inside, and these are new, are not in
netstandard2.0.

Moving data onto and off the network efficiently is (one of) the things that
Span<T> was created for.

*) [https://devblogs.microsoft.com/dotnet/system-io-pipelines-hi...](https://devblogs.microsoft.com/dotnet/system-io-pipelines-high-performance-io-in-net/)

~~~
legulere
Pipelines can also be used with much older frameworks:
[https://www.nuget.org/packages/System.IO.Pipelines/](https://www.nuget.org/packages/System.IO.Pipelines/)

~~~
SideburnsOfDoom
it can, but then it uses the less-performant shims of Span<T> and company in
[https://www.nuget.org/packages/System.Memory/](https://www.nuget.org/packages/System.Memory/)

------
tlarkworthy
Cool, do we think this will this work with unity?(the game engine)

~~~
jayd16
If it relies on .NET core then no.

------
jakoblorz
I really like the generate-on-save workflow integrated into vs

------
tasogare
> a Program Manger

Very glad French culture is infusing GAFAM (manger means to eat). More
seriously, typos like that in the first sentence of a post denotes a serious
lack of attention to details.

~~~
victorp13
I sometimes have thoughts like these. Mostly, before coffee in the morning.

I never actually feel the need though to actually go ahead and post them.
Kindly reflect on what you did, and where this is coming from.

~~~
efdee
Sounds like you haven't had your morning coffee yet...

