►
From YouTube: Working with Channels in .NET
Description
Channels enable a producer to safely pass data over to a consumer along with the appropriate notifications in both directions.
In this episode, Stephen Toub chats with Rich about the what, why and how of using the System.Threadding.Channels library. They walk us through a simple demo of using channels and also discuss the various strategies at our disposal.
[00:55] - What are channels used for?
[01:35] - Creating a basic channel implementation
[09:15] - Moving to System.Threadding.Channels
[11:34] - What are the benefits of using the System.Threadding.Channels?
[14:11] - What are some of the available back pressure strategies?
[20:58] - Working with varying number of producers or consumers
[21:54] - What are the merits of Channels compared to Pipelines?
[23:35] - Can channels be used out of process scenarios?
[24:30] - Can channels be used with pub/sub
[25:28] - What’s next for channels?
An introduction to System.Threading.Channels
https://devblogs.microsoft.com/dotnet/an-introduction-to-system-threading-channels/?WT.mc_id=ondotnet-c9-cephilli
System.Threading.Channels NuGet package
https://www.nuget.org/packages/System.Threading.Channels
System.Threadding.Channels on GitHub
https://github.com/dotnet/runtime/tree/df3930ecd237000813d1833286513d65557efffe/src/libraries/System.Threading.Channels
#dotnet #channel #concurrency #runtime
A
Hey
welcome
to
another
episode
of
the
on.net
show.
Today
we're
going
to
be
talking
about
system,
dot,
threading
channels
with
Steve
and
Taub:
hey
Steven,
rich
yeah.
It's
been
a
while,
since
you've
been
on
the
show.
It's
been
a
long
time,
so
we're
gonna
be
talking
with
channels
is
a
feature
that
you
know
you
built,
probably
in
concert
with
some
other
folks
and
what
first
another
product
did
this
for
ship
with
it.
A
B
A
channel
is
it's
actually
a
very
simple
mechanism,
and
the
whole
purpose
of
it
is
to
hand
off
data
from
one
party
to
another.
If
you
think
about
a
collection
like
list
of
tea
or
you
know
queue
or
stack
or
whatever
you
put
data
in
you,
take
data
out
and
the
only
thing
effectively
the
channel
layers.
On
top
of
that
is
the
synchronization
and
the
coordination
necessary
to
hand
that
data
from
one
party
to
another.
It
is
a
producer-consumer
collection.
Essentially,
in
fact,
you.
B
B
B
So
I'm
gonna
add
a
type
I'm
gonna
add
a
a
member
here.
This
is
a
concurrent
cube,
so
this
is
a
queue
that
I
can
access
for
multiple
threats,
concurrently
right.
So
this
is
basically
your
backing
store,
exactly
good
and
current
queue
and
then
I'm
gonna
add
the
synchronization
to
coordinate
the
interaction
between
the
two
players.
Concurrent
queue
was
thread
safe,
but
you
have
no
idea
when
I
add
something
to
the
queue
you
don't
know
when
it's
there,
so
you
need
feel
to
be
notified,
so
I'm
gonna,
add
a
semaphore
slim
mm-hm.
B
And
now
we
just
need
the
we're
gonna.
Add
two
methods
to
operate
on
this
we're
gonna,
add
a
method
to
write
and
a
method
to
read
so
I'm
gonna
add
a
a
write
method
that
takes
an
item
and
because
I've
sort
of
implemented
this
in
an
unbounded
fashion,
there's
no
limit
to
how
much
I
want
to
be
able
to
put
in
here.
My
write
method
is
just
a
synchronous
method,
a
space
synchronous
method,
because
it's
always
going
to
succeed,
subject
to
memory
limitations.
B
About
that,
we're
not
worried
about
that.
So
so
then
my
but
my
read
method
is
going
to
return
a
task
of
T
and
it's
going
to
be
ASIC
because
we
might
come
and
it
might
not
be,
might
not
be
anything
in
this
implement
in
the
collection.
So
we
have
to
wait
and
we
want
to
wait
without
blocking
the
current
thread.
I
see.
A
A
A
B
Not
in
write
this
code
using
this
to
sort
of
exemplify
the
core
concept,
that
is
a
channel
the
implementation
that
we
have
in
net
effectively
does
the
same
thing,
but
in
a
more
efficient,
more
robust,
more
functionality
matter
and
way
more
lines
of
code
and
way
more
lines
of
code,
yeah
yeah.
So
now
our
our
implementation
is
going
to
just
require
basically
four
lines
of
code.
B
So
two
right:
we
need
to
put
the
data
into
the
queue,
so
we
add
it
and
then
we
need
to
notify
anyone
who's
waiting
that
there's
something
here
and
to
do
that.
We'll
release
the
sum
on
the
semaphore,
which
basically
says
if
anyone's
waiting
on
this
there's
something
there's
something
that
you
can
go
check
out
and.
A
B
Light
is
that
the
busy
that's
what
the
zero
is
here,
so
the
semaphore
has
an
initial
count,
and
that
basically
says,
if
you
think
of
it
as
a
box
of
keys.
If
you
want
to
be
able
to
use
the
bathroom
that
requires
the
key
right,
you
need
to
grab
a
key
out
of
the
box.
If
there
are
no
keys
in
the
box,
you
have
to
wait
for
the
key
before
you
get
it
to
go
and
use
the
bathroom
by
creating
the
semaphore
with
zero
he's
in
it.
A
B
B
A
So
is
it
fair
to
say
this
is
kind
of
almost
the
opposite
of,
like
the
you
know,
add
ref,
release
kind
of
like
in
that
type
of
release.
It's
like
I'm,
basically
saying
I'm
like
giving
up
this
memory,
and
this
in
this
wording
it
makes
it
sound
like
I,
am
giving
something
I'm
releasing
this
to
the
semaphore
slim
for
it
to
represent
it.
It's
exactly.
B
B
A
And
should
I
think
it
was
test
out
run
as
running
on
another
thread.
You
can
think
of
it.
That
way,
sonic
is
more
pretty
different
way.
Have
you
introduced
ed
that
this
mechanism,
that
you've
just
created
is
thread
safe?
Should
we
think
of
this
particular
code
as
requiring
that
thread
safety
or
this?
Does
it.
B
Does
require
that
thread
safety
yeah.
So
if
you
forget
the
async
for
a
moment,
we
could
do
this
without
async.
If
we
didn't
have
all
this
async
stuff
in
here,
we
spawn
a
task.
The
whole
body
of
this
task
start
run
is
gonna,
be
sitting
on
some
thread,
pool
thread
mm-hmm,
either
blocking
waiting
for
a
period
of
time
or
accessing
the
channel
to
put
data
into
it
and
concurrently
we'd
be
sitting
here
in
our
loop
pulling
data
out
of
the
channel,
so
they
be
concurrently
out.
B
The
only
hesitancy
with
your
comment
about
the
threads
is
because
we
are
using
async
the
only
time
we're
actually
executing
on
a
thread
is
the
this
period
of
time
will
recall
right,
loop
around
and
then
hit
the
task
dot
delight.
Once
we
hit
the
test
dot
delay,
we
then
get
off
that
thread
and
we're
in
a
call
back
model
that
the
compiler
is
sort
of
you.
A
A
B
B
That's
why
it's
going
up
yes,
yeah,
and
so
you
know
fundamentally
that's
what
a
channel
is
now
system
to
writing.
Channels
means
we
don't
actually
have
to
write
this.
My
channel
class,
so
I'm
just
gonna,
go
down
here
and
delete
this
I've
got
my
namespace
here
and
instead
of
saying
new,
my
channel
I'm,
going
to
say
channel
dot,
create
unbounded.
B
B
There
are
many
different
possible
channels
in
concrete
implementations
of
a
channel
one
might
have
and
so
to
be
accommodating.
There
is
a
try
right
method.
We
could
have
also
had
said:
oh
wait:
C
writer,
dot,
write
async
and
now,
just
like
the
reader
waiting
until
something
is
available,
the
writer
will
wait
till
there
space
available
in
the
case
of
the
unbounded
collection.
This
will
complete
synchronously
in
the
case
of
a
bounded
collection.
This
will
wait
until
there
space
available
for
the.
A
A
B
Bool,
okay,
but
there's
no
out,
but
it's
it's
sort
of
the
corollary
with
the
try
read
which
has
now
totally
go
yeah,
and
so
this
is.
This
is
fundamentally
the
channels
we
can
run.
You
know
it's
do
the
exact
same
thing
we
did
earlier
and
we're
getting
the
exact
same
output.
We
saw
earlier
because
it's
doing
fundamentally
the
same
thing
now.
A
B
Is
so
first
if
the
right
to
maintain
the
code
yeah,
which
is
a
big
one?
Second,
the
implementation
here
is
much
more
efficient
than
the
one
that
I
showed
earlier.
Okay
and,
in
particular,
the
right
side.
The
the
writing
that
I
showed
earlier
was
was
fine,
but
the
reading
that
I
showed
earlier
it
was
going
to
be
allocating
a
new
task
for
every
piece
of
data
that
handed
back,
even
if
the
data
was
already
available,
because
we
don't
store
four
billion
possible
tasks
for
every
possible
integer
in
the
system.
B
So,
even
if
the
data
is
available,
synchronously
for
the
most
part,
you
end
up
creating
a
new
task
to
hand
back
that
data.
This
implementation,
if
you
can
read
the
fine
print,
doesn't
return
a
task.
It
returns
a
value
task,
and
this
not
only
allows
for
avoiding
allocations
when
completing
synchronously.
But
the
a
lot
of
the
code
that
you
mentioned
going
at
channels
is
this
will
avoid
allocations,
even
when
completing
asynchronously,
so
you
can
do
this
producer/consumer
model
and
get
a
very
efficient,
very
low
allocation
handoff
by
using
this
library.
B
This
library,
then,
also,
then
allows
you
to
use
the
same
kind
of
consumption
code
or
you
know
using
the
API,
while
changing
the
semantics
of
the
employed
channel.
So
here
instead,
I
could
say:
I
want
to
create
a
bounded.
One
and
I
want
to
only
allow
one
item
at
a
time,
and
now,
when
this
I'm
going
to
put
this
back
to
write
async
when
this
tries
to
write,
if
the
consumer
hasn't
yet
picked
up
the
data,
it
will
wait
for
space
to
be
avail.
B
So
now
I,
if
I
wanted
to
I,
could
put
a
task
dot
to
lie
here,
an
even
longer
one
and
previously,
without
this
being
bounded,
this
cut
crew.
So
we
just
kept
filling
up
the
collection
there.
We
know
back
pressure
now
there
will
be
back
pressure
so
until
the
reader
picks
off
the
next
item.
This
will
end
up
waiting
for
space
to
be
available,
and
we
can
run
that
as
well
and
we'll
see
now
that
you
know
every
two
seconds
we'll
see
the
next
number
printed
out
and
we're
not
growing
our
memory
significantly.
B
A
Do
you
think,
or
is
it
fair
to
say
that
this
system
has
some
useful
back
pressure
back
pressure
kind
of
strategies
with
it
such
that
I?
Guess
you
don't
necessarily
have
to
implement
those
other
than
use
these,
and
is
there
a
point
where
there
are
some
really
sophisticated
back
pressure
strategies
that
you're
aware
of
that?
Then
people
could
build.
On
top
of
this
sure,.
B
B
Various
things,
including:
what
do
you
want
to
have
happy
happen
when
it's
full?
There
are
various
policies
you
can
imagine
being
employed?
One
is
if
it's
fully
I
just
want
you
to
wait.
Another
is
if
it's
full
I
want
you
to
drop
one
of
the
items
that's
already
in
there
and
if
you
drop
one
of
the
items
in
there
which
one
do
you
want
to
drop
the
oldest,
you
want
to
drop
your
newest.
Do
you
want
to
pretend
that
I
took
what
you
gave
me
and
just
drop
it
on
the
floor
immediately?
B
So
those
sorts
of
policies
are
built
in,
but
there
are
certainly
more
complicated
ones.
One
might
like.
For
example,
let's
say
we
just
did
the
simple
I
want
to
only
allow
10
items
into
this
collection.
We
fill
it
up
now
we're
waiting.
Now
if
a
space
becomes
available,
we
could
wake
up
immediately
and
that's
what
we
will
do
or
we
could
say
you
know
what
that's
kind
of
an
efficient,
because
we're
gonna
be
ping-pong
and
back
and
forth
between
awake
and
sleep
and
a
wake
and
sleep.
B
So
maybe
what
we
want
to
do
is
actually
wait
for
sort
of
a
low-water
mark.
Wait
if
we
hit
the
bounds
all
right
so
then
wait
for
five
items
to
be
taken
out
and
only
then
wake
up
so
that
we
can
refill
all
five
and
then
go
back
to
sleep
yeah.
That
policy
isn't
currently
built-in,
but
we
could
add
it
in
the
future
or
because
this
is
just
returning
channel
of
tea,
which
is
an
abstract
class.
So
we
can
build
their.
A
Own
yeah,
it's
funny.
This
reminds
me
a
fair
bit
of.
There
was
a
developer
who
built
these
tasks
Combinator's
that
offer
different
policies.
You
might
know
this
developer,
maybe
yeah
it's
it's
reminiscent
of
that,
because
it's
basically,
this
I
guess
low-level
architecture
for
lack
of
a
better
term.
But
then
it's
like
there's
a
way
that
you
want
to
interact
with
the
things
in
the
system
and
there's
like
affordance
for
both
policies
that
come
with
the
system
that
you
can
use
and
also
once
you
can
build
on
top.
B
The
you
know
the
the
various
modes
of
consumption
that
you
talked
about
it,
so
we
tried
to
design
the
channel
API
to
be
very
simple
but
accommodate
the
various
schemes
that
someone
might
want.
So
if
you
look
at
what
ap
eyes
are
actually
available
from
the
writer,
there
are
basically
loops.
There
are
basically
three
primary
ways
of
getting
data
into
the
writer.
You
can
try
right,
which
we
saw
earlier.
That
would
say
that's
a
synchronous
that
is
synchronous.
B
B
So
we
can
say:
oh
wait,
wait
to
write
async
and
we
will
then
be
able
to
proceed
when
space
is
available.
Now,
if
you
had
multiple
writers
writing
to
the
channel,
you
might
have
a
race
condition
that
you
might
both
wake
up.
They
might
beat
you
to
it
and
then
you
have
to
wait
again,
but
you
end
up
with
typical
loops,
like
you
can
say,
while
oh
wait,
seedot
writer
dot
wait
to
write
async.
B
On
the
consumer
side,
there
are
various
modes
of
interacting
with
the
reader.
We
can,
you
know
and
there's
there
parallels
here,
we
can
try,
read,
we
can
wait
to
read
async
and
we
can
read
async
also
with
the
new
I,
a
sink,
innumerable
support
that
we
added
in
dotnet
or
three.
Oh,
you
can
actually
just
use
language
syntax
and
the
await
for
each
construct
to
loop
over
all
the
data
items
that
are
coming
into
the
channel.
B
So
I
can
say
rather
than
this,
while
true
loop
here,
I
can
say
a
weight
for
each
int
item
in
ctrader,
dot,
read
all
async
and
now
I
am
just
sitting
in
a
weight
loop
here
pulling
the
date
next
item
out
of
the
collection.
I,
don't
have
to
write
my
while
loop
I,
don't
have
to
say
we
don't
read.
You
know,
read
async,
it's
just
giving
me
the
next
item
each
time
I
say.
A
B
When
there's
no
more
data,
when
the
writer
says
you
know
what
I'm
done
so,
the
writer
side,
let's
say
we
had
I-
is
less
than
10
the
writer
a
weight
seed,
writer
write,
async,
I
and
just
yeah.
We
just
can
make
this
little
bit
faster
and
then,
when
he's
done,
the
writer
is
going
to
say
writer
dot
complete,
which
tells
the
channel
no
more
data
is
going
to
be
added
to
you
if
anyone's
waiting
for
data.
Let
them
know
that
it's
never
going
to
arrive
right.
B
You
can
say
you
know,
while
a
weight,
C,
dot,
reader
dot,
move
next,
that
wait
for
next
rather
and
then
console
I'll.
Just
do
ya,
console
dot,
write
line,
oh
wait,
C
dot,
reader
read
async.
We
could
do
that
too,
and
because
there's
only
one
consumer
right
now,
I
don't
have
to
worry
about.
You
know
someone
else
taking
my
my
data.
There
are
various
modes
of
interacting
this,
but
your
original
point.
A
B
You
can
have
any
number
of
each
and
the
built
in
channels
are
designed
by
default
to
accommodate
any
number
of
each.
However,
if
you
know
that
you
only
have
a
certain
mode
of
operating
in
in
order
to
support
any
number
of
each,
we
have
to
incur
some
additional
expense
I
see.
So
if
you
know
that
you
don't
need
to
deal
with
that,
like
you,
maybe
all
are
you
gonna
have
one
reader
or
one
writer.
You
can
set
properties
on
this
and
then
we'll
change
the
implementation
under
the
covers
to
provide
a
more
efficient
one.
B
A
B
Is
all
about
IO
and
if
that
is
its
bread
and
butter,
and
it's
focused
specifically
on
streams
of
bytes,
it's
much
more
aligned
with
system
iostream
and
it's
very
much
focused
on
scenarios
where
you
say,
read
a
buffer
of
data
off
the
network
process
that
buffer
in
some
way
potentially
just
may
be
parsing
off
some
frame,
header
data
and
then
handing
that
buffer
along
to
the
next.
The
next
stage
in
the
pipeline,
essentially
channels
is
not
focused
on
bytes.
It's
not
necessarily
limited
to
I/o.
B
In
fact,
some
of
the
initial
uses
of
it
aren't
at
all
in
the
area
of
I/o.
It's
really
about
arbitrary
handoff
of
data
between
two
parties.
In
the
same
process
it
could
be
in
rosslyn,
for
example,
they
effectively
use
a
channel
between
in
their
compilation,
server
a
request
arrives,
and
they
want
to
hand
that
off
to
the
thing
to
actually
do
the
compilation
we
can
use
it
in
our
HTTP
2.
B
A
B
Absolutely
could
the
core
abstraction
of
channel
I
mean
if
we
just
look
at
the
the
definition
here.
It
is
just
the
class
that
exposes
these.
You
know
channel
of
T
types.
This
is
an
abstract
class
that
exposes
a
reader
and
a
writer,
the
reader
and
the
writer
are
themselves
abstract
classes,
there's
nothing
in
the
abstraction
itself
that
ties
it
to
being
in
process.
So
anyone
could
implement
these
abstractions
to
go
across
any
kind
of
inner
process,
cross
machine
cross,
Network
boundary
in
the
Box.
These
create.
B
A
So
one
of
the
models
for
programming
a
little
bit
more
in
the
past
was
pub/sub.
You
were
talking
about
publisher
consumer,
which
is
it's
somewhat
similar,
but
Pub.
Something
I
think
is
slightly
different.
Could
you
use
channels
instead
of
pub/sub,
or
would
you
see
this
as
being
something
underneath
pub/sub?
You
could.
B
Use
it
as
an
abstraction
on
top
of
another
pub/sub
implementation,
and
you
could
use
it
inside
of
a
pub
sub
the
implementation,
but
because
there
isn't
there's
a
lot
of
other
machinery
that
goes
into
pub
sub.
Typically,
you
know
storing
the
information
for
later
in
some
persistent
database
or
whatever
it
may
be.
You
would
you
it
wouldn't
just
be
like
Papa
channel
in
there
and
you
know
be
done,
there's
be
a
lot
more
implementation
around
it,
but
you
could
absolutely
use
it
as
part
of
it
and
you
could
use
it
on
top
of
it.
Okay,.
A
B
I
mean
I
think
at
the
moment
we're
pretty
happy
with
the
core
abstraction.
We
welcome,
however,
a
feedback
on
new
AP
is
that
would
be
useful
to
people.
There
are
a
couple
suggestions
currently
pending
in
the
dotnet
runtime
repo
we've
added
one
or
two
additional
methods
in
this
release.
One
of
the
top
pieces
of
feedback
we
got
was
people
really
wanted
the
ability
to
just
inspect
how
many
items
were
in
there
generally
for
telemetry,
and
so
we
added
account
property.
A
B
So
you
can
go
to
if
you
want
to
look
at
the
source,
you
know
go
right
to
the
source,
it's
in
the
dotnet
runtime
repo,
and
there
is
a
new
get
package
if
you
want
to
use
it
without
a
framework
applications
or
wherever,
if
you
say,
file
new
project
and
dotnet
core
you'll,
have
it
available
to
you
immediately.
It'll
just
be
one
of
the
things
that's
automatically
there,
because
it's
in
the
core
framework,
the
shared
framework
and
I,
actually
wrote
a
blog
post
about
it
in
november/december.