►
From YouTube: From WCF to gRPC - Mark Rendle, Gibraltar Software
Description
From WCF to gRPC - Mark Rendle, Gibraltar Software
In 2006, distributed systems meant Service Oriented Architecture, and SOA meant SOAP. Microsoft created the closed-source, platform-specific Windows Communication Foundation (WCF) to enable .NET developers to build SOAP-based applications, services and clients using C# or VB.NET. 15 years later, .NET Core is open source and cross-platform, WCF is being retired, and Microsoft are recommending gRPC as the preferred solution. But can gRPC do everything that WCF did? In this session, Mark Rendle will look at the different modes and bindings of WCF, like two-way "duplex" bindings and server-side sessions, and show how similar functionality can be achieved in gRPC with ASP.NET Core 3.1, with all the performance and interoperability benefits of the gRPC protocol.
A
A
Last
year
at
the
build
conference,
microsoft
announced
that
they
were
no
longer
going
to
be
supporting
the
wcf
framework
for
creating
distributed
applications
in
net
core
and
beyond,
and
they
recommended
that
people
migrate
to
grpc
and
they
have
built
first
class
support
for
grpc
into
asp.net
core
to
facilitate
that.
So
in
this
talk,
I'm
going
to
talk
about
how
that's
going
to
work.
The
differences
between
wcf
and
grpc
and
potential
ways
that
customers
who
have
big
investments
in
wcf
can
migrate
to
grpc
running
on.net
core
with
a
minimum
of
effort
and
disruption.
A
So
microsoft
have
been
on
a
journey
with
net
for
a
few
years
now
they
created
created.net
core
back
in
2016
and
unlike
net,
which
has
been
a
windows
only
behemoth
of
a
framework
and
proprietary
closed
source
dot.
Net
core
is
fully
open
source
developed
in
the
open
on
github,
and
it
is
cross-platform.
A
A
A
It
had
a
secondary
mode
which
was
called
net
tcp,
and
this
was
a
much
more
high
performance,
much
more
powerful
binding
for
wcf
and
it
allowed
used
binary
wire
format
and
a
raw
tcp
connection,
and
so
it
was
much
faster
than
soap,
much
more
powerful.
But
the
problem
was,
it
was
only
implemented
in
wcfin.net
and
so
wcf
services
and
clients
could
communicate
using
net
tcp,
but
only
with
other.net
wcf
clients
and
so
forth.
A
And
then
it
was
my
favorite
thing
about
wcf
and
the
thing
that
caused
me
to
fail.
The
wcf
microsoft
certified
developer
exam
twice,
which
was
the
configuration
so
with
wcf.
The
implementation
of
your
service
was
completely
separate
from
the
specification
of
what
bindings
and
contracts
and
wire
formats
and
everything
else.
It
should
use
to
actually
handle
communication
between
client
and
server,
and
all
of
this
was
done
through
the
wcf
configuration
xml
files,
and
this
really
doesn't
fit
with
microsoft's
modern
vision
for
net
net
core
and
moving
forward
to
the
end
of
this
year.net.
A
Dense
clusters
of
linux
containers
in
kubernetes
in
various
cloud
platforms,
and
so
supporting
linux
as
a
target
host
operating
system
has
become
increasingly
important
and
re-implementing
wcf
to
run
on
top
of
linux
would
require
not
just
migrating
the
net
framework
parts,
but
also
the
parts
that
are
built
into
windows
would
have
to
be
re-implemented
to
work
properly
on
linux,
and
so
microsoft
have
decided
it's
2020
and
people
are
generally
not
using
soap
anymore
and
net.
Tcp
is
too
closed
off
and
two
windows
only,
and
so
they
have
embraced.
A
Grpc
and
grpc
compared
to
wcf,
really
provides
the
best
of
both
worlds.
Because
grpc
is
a
binary
protocol
using
protobuf,
it
gets
net
tcp
style
performance,
but
of
course,
grpc
is
implemented
on
dozens
of
different
platforms,
and
so
we
get
the
soap
interoperability,
and
all
of
this
is
just
out
there
and
microsoft
have
embraced
this
and
decided
that
they
are
going
to
become
part
of
this
grpc
ecosystem,
which
I'm
sure
we
all
agree
is
awesome.
A
Grpc,
of
course,
supports
net
and
java
and
go-
and
you
know,
an
endless
list.
If
it's
a
current
programming
language
or
a
current
development
platform,
you
can
be
pretty
certain.
It
supports
grpc,
whether
that's
officially
or
through
third-party
implementations,
for
things
like
rust
and
haskell
and
so
forth.
A
Microsoft
have
actually
created
an
implementation
of
the
grpc
web
protocol
and
it's
built
into
asp.net
core,
so
you
can
install
it
just
as
an
additional
package
into
your
grpc
application
and
with
a
couple
of
configuration
points,
you
can
actually
make
your
grpc
service
natively
support,
grpc
web
and
support
browsers
connecting
to
it
without
any
need
for
proxies
or
other
sidecar
instances
in
production.
So
that's
pretty
cool.
A
A
It
is
part
of
the
grpc
project,
though
it's
under
the
grpc
organization
on
github,
it's
maintained
by
microsoft
developers,
but
it's
open
source
and
there
are
other
contributors
to
it
as
well,
and
it
is
playing
very
nicely
in
the
grpc
organization
and
ecosystem
and
it
runs
on
the
kestrel
http
server,
which
is
an
incredibly
high
performance.
Http
server,
that's
built
into
net
core,
which
is
currently
sitting
somewhere
near
the
top
of
the
tech
in
power
benchmarks
and
the
clients
that
you
generate
for
net
core
use.
A
The
system.net.http
client,
which
again
is
a
very
high
performance,
http
client,
that's
natively,
implemented
in
net
core,
so
adding
grpc
to
an
asp.net
core
application,
looks
much
like
adding
anything
else
to
an
asp.net
core
application.
Here
you
can
see
the
startup
class
that
you
get
in
all
your
asb
net
core
applications
where
we
configure
services,
which
is
the
dependency
injection,
and
we
just
add,
grpc
as
dependency
in
there
and
then
in
our
configure
method,
which
is
where
we
set
up
our
routing
and
endpoints
and
middleware
and
everything
else.
A
A
A
A
So
the
first
thing
we
have
as
part
of
any
rpc
or
distributed
system
is
our
services
and
in
wcf
these
are
defined
using
service
contracts.
Service
contracts
are
typically
a
c-sharp
interface
decorated
with
some
attributes
and
the
attributes
declare
how
the
interface
is
going
to
be
exposed.
As
a
service,
you
can
put
things
in
there
to
control,
authentication
and
various
other
components,
but
you
define
your
service
contract,
your
your
public
interface,
using
this
c-sharp
interface,
and
then
you
would
implement
that
interface
in
an
actual
class.
A
A
A
Plain
old
c-sharp
objects,
but
they
can
also
return
lists
and
arrays
of
c-sharp
objects,
and
they
can
also
return
lists
and
arrays
of
primitives.
So
you
could
have
a
method
that
returned
a
list
of
strings,
whereas
rpc
really
just
supports
returning
some
kind
of
message
type
and
so
the
first
part
of
migrating.
A
Just
because
one
of
the
great
things
about
protobuf
and
grpc
is
the
forwards
and
backwards
compatibility
that
you
get
from
protobuf,
and
if
we
have
separate
request
and
response
objects
for
each
method,
it
means
less
chance
of
breaking
the
contract
with
an
irreconcilable
change
in
the
future
speaking
of
contracts.
The
next
thing
we
want
to
look
at
is
data
contracts
or
what
grpc
calls
messages
so
in
wcf,
a
data
contract
is
simply
a
plain
old
c-sharp
object
with
properties
and
again
decorated
with
attributes.
A
A
One
thing
that
I
ran
into
fairly
quickly,
particularly
working
with
enterprise
customers,
is
that
protobuf
does
not
provide
a
built-in
type
that
matches
to
c-sharps
decimal.
It
has
float
and
it
has
double,
and
we
know
that.
Actually,
if
you
set
a
a
float
on
the
protobuf
object
and
send
it
over
the
wire
and
then
extract
that
float
at
the
other
end,
it
will
still
have
exactly
the
same
value.
And
it's
when
you
do
maths
with
floats
that
you
discover
that
4.99
times
5
is.
A
24.9444449,
but
if
you
try
and
put
floats
and
doubles
into
a
lot
of
enterprise
customers
software,
they
are
just
they're,
not
happy,
they
don't
like
it,
and
so
I
had
to
find
a
way
around
this
google,
within
their
api
protobuf
definitions
actually
provide
a
money
type
which
works
by
having
units
and
nanos
and
a
currency
field,
and
so
I
just
created
a
a
copy
of
that
money
type
and
left
off
the
currency
and
called
that
decimal.
So
this
is
almost
identical
to
google's
money
proto
from
their
apis.
A
A
So
this
makes
that
decimal
value
type
play
nicely
with
c-sharp
decimals,
as
I
tend
to
be
working
with
people
who
are
moving
from
wcf
to
grpc,
they
usually
already
have
a
c-sharp
equivalent
of
their
data
contract
object,
their
message
object
as
well,
and
so
what
we
quite
often
do
is
build
a
similar
implicit
conversion
in
to
go
from
the
plain
old
c-sharp
object
to
the
grpc
message.
As
you
can
see
here,
this
converts
the
global
colon
colon
hotel
data
room.
A
A
A
Obviously
you
get
a
base
class
and
you
inherit
from
that
base
class
and
override
the
predefined
methods
to
provide
the
implementation
for
your
service,
and
so
that
makes
things
a
little
bit
different,
also
because
for
date
and
times
and
durations
there
is
no
built-in
implicit
conversion
between
google's
well-known
timestamp
and
duration
types
to
net's
built-in
date.
Time
offset
and
time
span
types.
A
A
Then
we
create
our
room
data
class
wherever
that's
coming
from,
obviously
normally
in
a
net
core
application,
we'd
be
getting
that
from
dependency
injection.
But
in
this
case
this
is
just
for
some
demo
code
and
then
we
create
our
response
from
the
protobuf
message
and
in
this
instance,
because
this
is
not
asynchronous,
we
just
return
a
task
from
result
response,
but
normally
obviously
this
would
be
talking
to
databases
or
upstream
services
or
other
microservices,
and
so
we
would
have
various
awaits
in
there.
A
So
this
essentially
moves
the
functionality
from
the
old
hotel
service
directly
into
the
grpc
service
in
the
new
project.
However,
there
is
an
easier
way
to
do
this.
Obviously,
this
hotel
service
there's
not
a
lot
going
on
in
that
implementation.
The
majority
of
wcf
services.
There
will
be
quite
a
bit
more
logic
in
each
of
those
implementation
methods,
and
there
may
also
be
other
private
methods
in
that
hotel
service
class
that
are
used
to
fulfill
these
requests.
A
And
so
there's
a
quick
cheat
mode
that
I
like
to
recommend
where,
if
you
can
get
your
hotel
service
type
to
compile
under
net
core
which,
as
long
as
you're,
not
using
particularly
edge
case
libraries
or
new,
get
packages,
you
should
be
able
to
do
dot
net
core
3.1
and
net
5
support
ado.net
for
most
of
the
databases
out
there.
They
also
support
entity
framework
6.3
as
well
as
entity
framework
core.
A
A
So
grpc
has
various
modes
and
wcf
has
various
different
bindings
and
types
of
service
that
it
supports,
and
so
I
want
to
talk
about
those
briefly
wcf,
the
the
most
straightforward
mode
and
the
mode
that
we've
just
been
looking
at.
With
that
hotel
service
is
just
simple
request
response.
The
client
sends
a
request.
A
That
return
are
innumerable
of
something
you
can
map
that
very
nicely
to
a
grpc
streaming
service,
which
in
c
looks
like
the
code
on
the
right
here
where
we
get
our
response
stream
passed
in,
and
then
we
just
enumerate
through
all
the
rooms
from
our
service
contract
and
write
those
back
to
the
response
stream,
and
this
gives
us
if
you
were
using
net
tcp
binding
and
using
that
feature
of
via
enumerable.
This
gives
you
the
same
functionality.
A
It
also
meant
that
when
a
instance
of
the
service
contract
type
was
created
on
the
server
it
could
be
held
in
memory,
and
it
basically
created
a
persistent
session
that
the
client
was
permanently
connected
to.
So,
if
you
had
any
fields,
for
example
on
that
class,
then
those
fields
would
keep
their
value
for
as
long
as
that
session
stayed
open
for
as
long
as
the
duplex
binding
was
held,
a
duplex
binding
in
wcf
looked
something
like
this,
so
we
would
have
our
calculator
service.
A
This
is
microsoft's
canonical
example
of
almost
anything
ever
as
a
calculator,
and
so
they
illustrated
the
duplex
service
with
a
calculator
where
the
client
just
kept
sending
new
values
and
the
server
kept.
Calling
back
a
message
on
the
client
saying:
here's
the
current
result:
here's
the
current
result,
and
so
that
was
implemented.
Something
like
this,
where
you
would
get
the
callback
interface,
which
was
a
proxy,
obviously
wrapped
around
the
interface
declaration.
A
A
A
It
reads
all
the
incoming
messages
off
the
request
stream
does
a
switch
on
the
action
case,
which
is
how
the
c
sharp
code
gen
in
grpc
and
protobuf
says
this
is
the
one-off
field
that
was
set
and
invokes
the
relevant
method
based
on
which
one
of
those
values
was
set.
This
is
a
fairly
simple
implementation.
A
A
A
Also
wcf
didn't
natively
support
encryption,
but
there
were
the
ws
encryption
standards
and
you
could
run
it
over
an
https
connection.
If
you
were
doing
soap
over
http
grpc
because
it
uses
http,
2
kerberos
windows,
authentication
is
actually
impossible.
You
just
can't
do
it.
Http
2
does
not
support
it,
and
so
with
grpc.
A
The
standard
authentication
method
is
bearer
tokens.
You
can
combine
that
with
adfs.
You
can
get
tokens
from
your
active
directory
federation
server
and
then
you
can
use
those
as
bearer
tokens
in
your
grpc
application,
and
then
you
can
use
the
asp.net
core
built-in
adfs
authentication
library,
to
authenticate
those
calls
on
the
server
and
obviously
grpc
also
provides
mutual
tls,
where
the
client
and
server
both
provide
a
certificate,
and
all
communication
is
encrypted
using
that
certificate,
and
it
also
means
that
both
sides
can
verify
that
the
other
party
is
the
correct
thing.
A
It
is
a
commercial
project
because
it
was
too
big
to
do
as
open
source
and
it's
properly
supported
with
support
contracts
and
consulting
and
so
forth,
but
that
is
available.
If
anybody
is
interested
in
that
at
the
moment
it
does
asp.net
wcf
to
grpc,
it
will
be
doing
some
additional
types
of
conversion
as
well,
but
that
is
available
at
visualrecode.com.
A
I
hope
that
was
helpful.
I
hope
it
was
informative.
I
hope
you
enjoyed
it
and
I
hope
that
if
you
are
using
wcf,
this
has
made
you
see
that
grpc
can
fulfill
that
need
for
you
and,
if
you're
already
using
grpc,
then
maybe
reach
out
to
some
wcf
teams,
if
you
know
any
and
try
and
evangelize
grpc
to
them
and
show
them
everything
that
it
can
do
for
them.
Thank
you
very
much
and
enjoy
the
rest
of
the
conference.