►
From YouTube: S107 - Build great libraries using .NET Standard
Description
Want to create great .NET class libraries? Confused about .NET Standard, .NET Core, and .NET Framework? Watch this talk to learn how you can easily support multiple platforms with .NET Standard and no compromises, thanks to via multi-targeting. We'll also cover the other aspects, such as versioning, strong naming, and binding redirects.
A
Little
friends
of
dotnet
I'm
in
will
and
forth,
and
you
can
find
me
on
twitter
at
tara
jobs,
where
it
seems
to
me
my
full-time
job,
these
days
to
give
advice
on
how
to
build
dotnet
class
libraries.
So
we
thought
it
might
be
useful
to
do
a
session
on
how
you
can
build
great
class
libraries
using.net
standard
and
don't
instant
itself
is
not
necessarily
the
higher-order
bit
here.
It's
more
like
the
general
approach
for
building
class
libraries.
A
So
let's
get
started
with
the
overview
of
what
is
done
in
standard,
because
it
still
seems
a
lot
of
confusion
about
what
the
standard
actually
is,
how
it
works
and
why
we
have
so
many
different
things
called
dotnet
something
so,
first
of
all,
as
the
name
kind
of
implies
that
the
standard
is
a
specification
and
by
specification,
what
we
really
mean
is
a
set
of
api's,
but
it's
not
just
that.
It's
also
a
template.
A
You
can
use
to
build
class
library,
so
you
can
either
do
this
with
Visual
Studio
or
you
can
do
it
with
the
NCI.
They
just
say:
don't
need
new
class
library,
maybe
default
you
to
donate
standard
and
what
that
means
is
you're
building
a
class
library
that
is
restricted
to
the
API
said
that
is
just
in
dotnet
standard.
So
you
cannot
actually
call
any
operating
system
specific,
api's
or
framework
specific
API
and
that's
useful,
because
it
means
that
you
know
that
the
resulting
class
libraries
will
truly
work
everywhere.
A
So
another
way
to
look
at
this
is
that
the
standard
is
something
like
the
HTML
specification,
so
it
has
a
whole
bunch
of
language
constructs
and
other
things
in
it
that
allow
it
to
express
your
website
right
and
then
you
have
actual
browsers.
In
our
case,
it's
donate
coral
and
infirmaries
everyone
that
can
run
your
class
libraries
in
the
context
of
an
application.
So
that's
roughly
how
you
should
think
about
that.
A
Another
way
to
look
at
this
is
a
term
that
we
often
use
as
vertical.
So
you
can
think
of
the.net
platforms,
a
framework
or
and
xamarin
as
verticals
and
their
vertical,
because
they
give
you
an
end-to-end
experience
with
an
application
model,
a
UI
framework
very
often,
and
that
is
where
you
build
your
applications
in
and
then
the
standard
is
the
orthogonal
thing
to
that
which
is
the
horizontal.
A
So
it
covers
all
the
api's
and
all
the
foundational
pieces
that
allow
you
to
express,
for
example,
business
logic,
and
you
know
general
purpose,
libraries
like
json,
parser
and
other
things
and
allow
them
to
run
truly
everywhere.
So,
what's
in
the
standard,
the
phone
is
too
small.
It
doesn't
really
matter.
The
real
point
here
is:
there's
a
lot
of
Technology
in
it
and
to
summarize
it
it
is
all
the
foundational
pieces
that
you
already
know
from
net.
So
there's
really
not
any
new
concepts
in
it.
A
Usually
it
is
just
things
already
know
like
I/o
collections,
networking
all
the
things
you
expect
to
have,
and
you
want
to
build
reusable
libraries
that
run
everywhere
and
if
you
understand
the
tool
we
have
about
you
know,
40,000
API
is
or
something
like
that.
So
it's
very,
very
rich
compared
to.
Let's
say
portable
class
libraries
and
other
experiences
we
had
in
the
past
to
ride
the
usable
libraries,
so
it
is
truly
a
really
cool
thing
to
use.
A
Another
question
that
I
often
get
is
version
numbers
like
how
many
versions
do
we
have
in
dotnet
standard
and
where
do
they
run?
And
all
of
that
point
is
don't
worry
about
it.
You
should
really
just
start
with
daunting
sender
2.0.
It
is
the
best
trade-off
between
reach
and
number
of
api.
Is
that
you
have
available
to
you.
So
if
you're
new
to
don't
need
standard-
and
you
don't
know
how
to
select
the
version-
number
don't
worry
about
it,
just
started
with
200
and
you're
pretty
much
good
to
go.
A
So
another
thing
that
always
comes
up
is
the
standard
is
open
source.
Most
of
you
who
are
followed
on
and
for
a
while
now
know
that
pretty
much
everything
we
do
these
days
is
open
source
and
the
standard
is
no
different
from
that.
The
only
thing
that
makes
this
line
that's
slightly
different
is
that
we
also
have
a
review
board
and
the
review
board
has
representatives
from
all
the
dotnet
platform
owners,
as
well
as
from
the
community,
which
is
represented
by
the
dotnet
foundation,
and
anybody
can
propose
API
is
to
be
added
to
the
standard.
A
The
only
two
things
we
require
is
that
the
API
already
shipped
somewhere
in
a
stable
form,
so
the
dotnet
standard
review
body
is
not
an
API
design,
review
body.
It's
not
about
building
new
technologies,
it's
more
about
deciding
which
technologies
should
be
in
the
standard
and
become
universal.
So
it
is
more
about
the
letter
less
about
the
format.
So
you
want
to
build
api's.
You
should
just
go
to
Mon
org.net
core
or
wherever
concrete
platforms
you
have
of
an
open
source
process
where
you
can,
actually,
you
know,
engage
with
the
developers
and
design
a
api's.
A
The
other
thing
we
require
is
that
one
of
the
one
of
the
people
on
the
review
boards
points
of
the
API-
and
you
know,
shepherded
through
the
whole
approval
process
and
if
you're
curious
is
the
next
version
of
the
standard
that
is
currently
in
planning
is
to
one,
as
you
might
expect
from
the
version
number
that
we
just
took.
Oh
so
now
the
next
one
is
2.1
and
there's
a
funny
talk
on
github
that
you
can
read,
and
you
know,
there's
full
requests
with
API
editions.
A
So
if
you
want
to
be
involved
with
the
standard,
that
is
where
you
can
do
that.
Alright.
So
before
we
go
into
the
demo
on
how
we
build
on
ascended
libraries,
I'm
gonna
talk
a
little
bit
about
platform,
specific
API
and
how
that
works
with
the
standard,
because
it's
all
sort
of
confusion
around
that
subject.
So,
first
of
all,
we
announced
the
windows
compatibility
pack
almost
a
year
ago,
we're
actually
exactly
a
year
ago.
A
I
think
at
this
point
and
it's
effectively
all
the
things
we
haven't
done
at
frameworks
that
were
not
in
dotnet
core,
and
so
it's
you
know
all
the
usual
suspects.
Like
drawing
or
did
we
see
the
registry
a
bunch
of
stuff,
it's
about
27,000
API,
so
it's
quite
sizable.
Some
people
ask
me
was
that
no
Linux,
compact
pack
and
no
Mac
compact
and
the
reason
for
that
is
pretty
simple-
that
dotnet
just
started
on
Windows.
So
the
vast
majority
of
thought
for
specific
API,
as
we
have
happened
to
be
window
specific
API,
is
moving
forward.
A
A
So
you
can
reference
the
compact
pack
from
net
standard.
Now
the
concern
is
well.
The
standard
is
supposed
to
be
for
libraries
that
run
everywhere.
What
happens
now
when
you
use
AP
is
that
are
not
available
everywhere.
What's
the
experience
going
to
be
well?
First
of
all,
the
experiences
will
be
that
the
application
will
crash
with
a
platform
unsupported
exception.
So
the
expectation
is
that
user
library
or
author
either
decide
that
you
don't
support
your
library
outside
of
Windows.
A
What
did
you
guard
your
calls
with
an
if
statement
that
says
if
you're
running
on
Windows
call
the
API,
otherwise
don't
call
the
API
so
problem
that
developers
always
have
is
no
well?
How
do
I
know
how
bad
it
is?
How
many
times
do
I
call?
Those
API
is,
do
I
even
know
it's
a
bit
of
specific
API,
and
so
we
have
an
analyzer
for
that
that
I
will
I
will
demo
in
more
detail,
but
basically,
what
you
get
in
the
idea
is
you
get
squigglies?
A
It
will
tell
you
that
you
call
an
API
that
it's
not
supported,
so
you
get
a
warning
and
then
you
have
to
do
something
about
that
and
it's
not
just
in
the
ID.
It
also
happens
on
the
command
line,
so
even
if
you're,
building
Tullio
on
the
command
line
and
don't
use
an
ID
at
all,
we
also
got
you
covered
there.
A
A
It's
a
dotnet
framework
console
application
and
it's
a
net
framework
class
library
right
now
and
it's
a
pretty
simple
class
library
all
it
does
is.
It
is
a
logger,
basically
an
abstraction
of
a
logging
framework
and
it
allows
you
to
lock
statements
out,
I
think
pretty
much
everybody
who
builds
libraries
or
you
know,
applications
for
living-
has
built
something
like
that
at
some
point
in
their
career.
So
if
I
run
the
application,
nothing
spectacular
happens,
the
application
just
logs
something
and
the
login
files
written
somewhere.
So
not
too
spectacular.
A
Now,
let's
say
we
want
to
use
this
login
library
on
dotnet
core
so
right
now
this
thing
is
targeting
don't
need
framework
in
our
case
4.61,
but
it
could
be
4.
5
4
doesn't
really
matter
whatever
the
case
might
be.
So
how
would
you
convert
this
thing
to
the
standard?
And
so
the
first
thing
you
should
be
doing
is:
if
you
have
a
packages
that
config
file
is
migrated,
this
package
is
the
config
file.
A
Let
me
actually
change
one
sitting
here.
First
interesting,
let
me
check
one
thing
here:
yeah
here
we
go.
So
if
you
have
this
tool
now
migrate
package,
look
conflictive
packet
reference.
We
don't
only
have
to
do
it
by
hand.
All
you
have
to
do
is
invoke
this
wizard
here
and
what
it
will
do
is
it
will
tell
you
whether
the
package
can
be
converted
to
package
references,
and
if
so,
it
will
just
do
it
for
you
and
package.
References
are
the
way
how
we
do
things
moving
forward
in
general.
A
So,
even
if
your
standard
infirmary
should
generally
move
to
packet
references
as
a
better
way
to
reference
NuGet
packages.
So
now
we
have
this
project
still
targeting
framework,
and
so
the
next
step
will
be
to
convert
it
to
donut
standard.
So
the
easiest
way
to
do
that
is
to
just
create
a
new
net
standard
project.
I,
don't
even
care
what
it's
named,
because
the
only
reason
I'm
creating
this
is
so
that
I
can
edit
it
and
get
this
template
here.
A
I
never
go
to
the
my
donut
framework
project,
click,
unload
click,
Edit
I,
know,
I
will
replace
the
contents
of
this
file.
With
this
new
thing
here
and
now
comes
the
time,
they
actually
have
to
read
some
XML
and
have
to
be
aware
of
what,
in
this
build
works.
Most
of
the
things
here
are
thing
just
default
settings
you
can
safely
ignore
them.
A
References
are
defaulted
and
don't
incident.
You
don't
have
to
worry
about
them
as
well.
Cs
files
are
included
by
default.
Everything
in
the
directories
don't
have
to
worry
about
those
either.
So
the
thing
you
usually
have
to
worry
about
are
package
references
or
project
references,
and
you
want
to
you
know,
cut
those
guys
out
and
put
them
in
here
and
then
you
can
basically
delete
all
the
rest,
and
then
you
now
have
basically
a
new
project.
Now,
if
we
click
reload,
I
may
have
done
something
bad.
A
Let
me
edit
the
product
again:
oh
yeah,
totally.
The
problem
is
you
need
to
be
careful
when
you
copy
XML
snippets
that
you
stay
consistent,
so
package
references
have
to
be
in
item
groups
and
msbuild,
so
that's
really
fix
net.
So
it's
my
first
sort
of
demo
fail
brace
yourself.
There
might
be
more
because
it's
pretty
demo
heavy,
so
we
can
remove
this
project
because
we
need
it
and
now,
when
we
look
at
the
properties
of
this
thing
here,
this
thing
no
targets,
don't
in
standard
2.0.
A
That's
we
will
you
believe
it
for
now,
because
that's
what
gives
us
the
best
API
said
now.
If
I
rebuild
this
thing,
I
will
get
a
bunch
of
built
breaks
the
first
ones
you
run
into
our
duplicate
attributes
because
they
used
to
be
written
to
a
file
by
the
by
the
project,
template
and
all
that
generated
during
the
build.
So
in
my
case,
I
will
just
delete
them
because
I
don't
need
them.
A
A
So
in
our
case
we
just
installed
everything
for
now
and
let's
try
to
rebuild
this
guy
now
now
we
have
zero
arrows
and
if
I
run
my
application,
the
application
continues
to
work
just
fine,
but
no,
you
might
actually
edit
on
a
core
application
of
track.
It's
Linux
and
you
might
use
the
library
and
then
you're
disappointed
when
you
reach
this
line
here,
that
no
blows
up
top
will
not
support
it.
So
how
would
you
know
about
this
up
front?
Well,
you
would
install
this
other
package
that
we
have,
which
is
our
analyzer
package.
A
And
now
you
can
see
you
get
these
small
squiggles
in
the
IDE,
and
it
tells
you
here
that
your
according
API
does
not
support
on
linux
or
mac
OS,
and
so
the
nice
thing
is,
it's
also
an
error
or
should
say
a
warning
on
the
command
line.
If
you
don't
like
these
things
to
be
warnings,
you
can
also
make
them
actual
arrows,
but
just
go
in
here
and
say
this
ap
has
no
support
on
all
platforms.
You
can
say:
I
want
this
to
be
an
error,
and
when
you
rebuild
now,
you
actually
get
build
errors.
A
When
you
use
types
or
specific
API
s,
how
would
you
fix
that?
Generally
speaking,
my
recommendation
would
be
you
either
refactor
your
code
to
literally
remove
the
dependency,
if
that's
possible,
which
in
our
case
we
actually
could
or
if
you
want
to
give
your
windows
developers
a
slightly
better
experience,
but
you
also
can
do
is
just
instead
of
calling
the
API
like
this.
You
guard
the
API
call
which,
in
our
case
we
do
with
runtime
information.
Are
you
running
on
Windows?
A
A
So
what
I
can
now
do
is
I
can
invoke
the
quick
fixer
for
the
analyzer
to
say,
suppress
this
particular
thing
here,
because
I
know
I
guarded
the
caller
correctly
and
now
you
basically
have
code
that
compels
again
and
you
know
is
safe
to
be
used
on
Linux,
because
in
our
case,
if
we
don't
run
on
Windows,
we
just
default
the
setting
to
something
sane,
and
then
we
just
write
the
log
file
to
that
location,
all
right.
So
the
next
thing
you
probably
want
to
do
once
you
have
it
done
in
standard
library.
A
Is
you
want
to
package
it
up
as
a
new
get
package?
And
historically
this
has
been
quite
of
a
you
know,
rocket
science.
Your
thing
to
do.
We
have
to
read
on
how
to
put
NuGet
packages,
create
a
new
spec
file,
calling
you
get
pack
figure
out
how
to
invoke
it
in
your
build
at
the
right
time,
and
all
of
that
you
don't
only
have
to
do
that.
You
can
just
say
right
click
properties,
package.
A
All
you
have
to
do
now
is
say
gentleman
you
get
package
on
built
and
when
you
do
that,
lets
save
the
project
build
our
project
and
then
we
go
into
the
output
folder.
Now
we
see
here
we
have
a
fabric,
am
logging
package
here
and
that's
a
NuGet
package
and
it
just
contains
2.9
standard
dll
in
it.
So,
however,
check
box
boom,
you
got
a
new
that
package,
so
the
next
question
then,
is
often
grade.
A
The
compared
pack
is
out
there
I
get
access
to
window
specific
api's,
but
what,
if
you
have
too
tall
API
is
that
are
not
part
of
the
windows
compact
pack?
Yet
what
do
I
do
or
what
happens
if
I'm
you
know,
James
and
I
have
to
write
a
wrapper
around.
Let's
say
the
iOS
API
is
or
the
Android
API
is.
What
would
I
do
in
that
case
and
if
a
demo
for
that
as
well,
let
me
just
quickly
switch
to
that
demo
demo
to.
A
So,
in
my
case,
I
have
a
very
simple.
Let
me
first,
we
built
this
to
make
sure
I
actually
build.
It's
always
a
good
start.
To
start
a
demo
of
something
that
works.
Sweet
builds,
so
I
have
an
application
here.
Let
me
just
quickly
launch
it:
I
have
I
should
have
two
applications
actually
have
a
dotnet
framework,
WinForms
app.
A
That
basically
shows
me
my
GPS
coordinates
and,
as
you
can
tell
I'm,
clearly
a
form
designer,
because
I
didn't
even
bother
to
name
anything
here.
But
the
point
is
that
I
have
the
same
thing
as
well
for
you
WP.
So
if
I
say
so
to
start
a
project
right,
click
deploy
I
can
launch
that
as
bit
as
well,
and
once
it's
done.
A
Yep
and
now
I
have
you
WP
app.
That
also
shows
me
the
GPS
position,
and
what
I
do
here
is
I
have
a
dotnet
framework
library,
as
you
can
see,
by
the
names
I've
done
in
framework
library
and
I,
have
you
WP
library,
and
they
are
basically
just
encapsulating?
What
do
you
have
to
do
to
get
the
GPS
coordinates
and
on
the
network
side,
I
would
use
system,
dot,
device,
taught
location,
and
we
should
the
API
I
think
in
three
five,
four,
oh
maybe
so.
This
was
before
we
actually
had
a
Singh
api's.
A
So
these
are
all
basically
blocking
the
UI
thread.
So
I
put
this
all
into
a
tasks
run
this
on
a
worker
thread
and
I
have
to
do
some
dance
around
waiting
for
the
device
to
get
ready
and
blah
blah
blah
and
then
at
some
point,
I
get
a
location,
but
at
the
end
of
the
day,
all
I
have
to
return.
Is
the
latitude
and
longitude
right
and
so,
but
would
be
nice
if
I
could
just
wrap
this
as
a
library
and
use
it
from
all
my
applications
right?
A
The
problem
is
that,
on
the
uwp
side
of
the
house,
the
API
task
looks
exactly
the
same:
I
just
get
coordinates
latitude
longitude,
ignore
all
this
quickly,
see
I,
don't
know.
What's
going
on
here,
probably
on
a
bad
build
of
Visual
Studio,
it's
the
pleasure
of
dog
fooding,
I
guess,
but
this
looks
very
different,
so
this
des
api's
are
relatively
recent
and
so
they've
already
shipped
acing
from
the
get-go,
so
they
already
have
an
async
way
to
call
the
api's,
and
you
know
you
don't
have
to
do
any,
create
the
dances
here.
A
You
just
extract
the
two
values
and
you
return
them.
The
point
being
is
that
this
signature
here
looks
exactly
the
same
as
this
signature
here
all
right.
So
what
would
be
nice
if
I
could
write
it
on
a
standard
library
and
rep
this
and
through
the
magic
of
switching
branches,
because
I'm,
a
p.m.
I
cannot
actually
write
code
as
it
turns
out.
I
just
switched
to
another
branch,
and
now
I
have
a
single
file.
Let
me
just
build
this
guy
first,
yes,
let
me
one
package
restore
then
rebuilt.
A
A
A
So
we're
saying
if
you're
building
forgotten
framework
for
61
then
do
what
we
did
in
the
dotnet
framework
project
before,
if
you
WP,
let
me
do
this
other
thing
and
otherwise
we
throw
up
from
not
supported,
and
in
the
editor
you
get
this
very
helpful
thing
over
here
where
you
can
switch
the
context.
So
this
is
my
view,
I
get
when
it's
done
it's
standard.
This
is
the
view
I
would
get
from
461.
So
you
can
see
that
this
is
now
all
grayed
out.
A
This
is
all
in,
so
you
basically
can
totally
you
intellisense
for
the
relevant
platform
and
you
basically
the
right
data
in
intelligence.
Now,
how
does
this
magic
work?
Well,
if
you
actually
look
at
the
project
file
instead
of
saying
target
framework,
it
says
target
frameworks
and
that
enables
you
to
put
in
multiple
frameworks.
A
Semicolon
separated,
and
what
happens
now
under
the
covers,
is
that
this
project
is
build
three
times:
one
photon
in
standard
one
photon
at
framework
and
one
value
WP
and
then
I
can
just
do
conditions
and
say,
for
example,
if
I
am
targeting
for
461,
then
include
this
reference
here
or,
if
you're
building
anything
else
just
include
this
new
get
package
or
we'll
also
add
a
condition
on
the
nuga
package
itself.
If
I
wanted
to
do
so,
this
way
you
can
effectively
encapsulate
all
the
different
platforms
if
ik
stopped
from
from
your
library.
A
A
Yeah,
which,
in
my
case,
doesn't
work
because
it
isn't
built.
Let's
try
this,
maybe
this
project
builds.
What
I
can
do
here
is
in
the
bin
debug
folder.
Now
you
have
subfolders.
Might
you
know,
have
one
folder
per
TFM
because
we
produce
multiple
different
binaries,
but
what
we
also
have
is
we
have
this
new
get
package
here
and
if
you
look
into
this
new
get
package,
you
will
now
see
that
this
new
get
package
now
has
one
binary
poor
platform.
A
So
from
your
consumer
standpoint,
they
don't
have
to
know
that
you
did
anything
crazy
right
from
their
point
of
view,
it's
just
one
library
and
you
just
get
different
implementations
based
on
the
operating
system.
You're
running
it
from,
and
so
this
is
exactly
what
James
is
doing
in
Xiamen
essentials.
To
give
you
the
experience
where
you
can,
you
know,
have
one
API
surface,
that
bridges
effectively
n
number
of
devices,
so
you
can
effectively
bridge
any
platform
differences
yourself
by
providing
these
abstractions.
A
A
But
even
if
you
do
that,
you
should
never
drop
support
for
the
standard,
because
if
you
do
that,
that
means
your
package
can
no
longer
be
installed
into
the
net
Center
project,
which
no
means
not
only
have
you
been
forced
to
write
a
file
specific
code.
All
your
consumers
would
have
to
do
this
now
as
well,
which
kind
of
defeats
the
point,
because
your
point
of
this
library
is
so
that
you
can
encapsulate
this
when
your
consumers
don't
have
to
do
this
crazy
stuff,
so
demo
drop
support
for
the
standard.
The
other
thing
is
well.
A
What
happens
in
this
case
is
when
you
have
ap.
Is
that
throw
my
general
recommendation
is
also
add
a
capability
API
that
returns
whether
the
API
is
supported.
So
in
my
case,
for
example,
let
me
just
quickly
show
you
what
I
mean
by
that
in
this
class
here.
What
I
could
do
is
I
could
just
create
a
boolean.
P'tee
is
supported.
It
returns
true
for
Don
and
framework
and
windows.
You
WP
and
returns
false
for
everything
else.
A
It's
just
automated
for
them
and
then
lastly,
like
if
you
do
multi
targeting
I
highly
recommend
you
check
out
or
novotny's
amazing
msbuild,
sdk
extras
NuGet
package,
which
basically
does
most
of
the
heavy
lifting
that
you
have
to
do
in
order
to
reach
you
WP
and
xamarin
from
a
multi
targeted
project.
So
it's
a
really
neat
thing
to
check
out
alright.
A
Now,
let's
talk
about
the
elephant
in
the
room
when
asked
yesterday
on
Twitter
what
you
would
like
me
to
talk
about,
one
thing
that
popped
up
a
lot
was:
what's
up:
I've
done
it
for
America
next
era:
it's
there
seems
to
be
some
issues,
so
let
me
start
with
apologizing
and
say
I'm
deeply
deeply.
Sorry,
we
had
a
good
idea
and
we
tried
really
hard.
Unfortunately,
some
things
don't
turn
out
to
work
super
well.
A
So
when
we
shipped
out
in
standard
2.0,
that
was
roughly
I
want
to
say,
six
months
after
we
shipped
done
it
framework
for
six
one
I
believe,
and
so
what
we
said
at
the
design
point
of
to,
or
was
it
would
be
really
neat
if
done
in
framework.
Four
six
one
could
support
down
in
standard
2.0.
The
reason
being
is
that
most
of
the
api's,
if
not
all,
of
the
AP
is
they've
been
new
internet
standard
2.0
were
already
available
in
dotnet
framework
for
a
six
month.
A
So
the
only
thing
we
thought
we
have
to
do
is
change
the
new
get
mapping
to
consider
four
61's
implementing
a
standard
2.0.
Unfortunately,
we
found
out
over
the
last.
You
know
six
to
twelve
months,
that
there's
a
very
long
tail
of
issues
and
I
don't
have
enough
slides
to
tell
you
what
the
problems
are.
Generally
speaking,
what
you
should
take
away
from
this
is
that
if
you
want
to
consume
anything
higher
than
SN
and
1.5,
you
should
prob
the
Burano
framework
for
seven
now.
I
realize
that
that
it's
not
always
a
choice.
A
You
have
right.
If
you're
a
library,
author,
you
don't
control
what
your
what
your
customers
are
using.
So
one
thing
that
you
can
do
as
a
library
author
is,
do
multi
targeting
and
add
the
dotnet
framework
for
61
output
to
your
library.
So
you
have
a
basic
producer
binary
that
is
specific,
donut
framework,
so
your
customers
don't
have
that
problem.
You
still
compile
the
same
code.
You
don't
have
to
change
your
source
code
at
all,
but
you
just
previously
produce
two
binaries,
as
opposed
to
just
one
binary
and
there's
an
implication
author.
A
You
should
operate
two
four,
seven,
two,
if
you
consume,
don't
assign
a
2.0
binaries,
because
the
experience
will
be
so
much
better
so
again,
I'm
very
sorry.
For
us.
The
major
learning
here
is
that
after
that
M
platform
shipped,
we
would
never
ever
change
the
mapping
which
don't
in
standard
version.
This
platform
is
supposed
to
implement
because
you
know
bad
things
happen.
If
we
do
that,
all
right,
strong
naming
so
strongly
immune,
is
a
topic
that
has
triggered
a
bunch
of
strong
opinions.
I
would
say
so
before
we
go
into
them.
A
A
So
basically,
in
this
case,
what
we
have
here
is
we
have
oopsy-daisy,
make
sure
zoom
in
here
something
reasonable,
never
mind
anyway,
so
they
use
an
assembly
name
that
you
have,
and
this
has
the
public
key
talk
on
the
right
hand,
side
and
the
public
key
token
is
the
thing
that
you
basically
get
from
store
naming
assemblies.
You
should
not
confuse
strong
naming
by
the
way
before
20
code
signing
off
any
code.
A
It
just
gives
a
certificate
signature
to
the
code
and
it
indicates
who
authored
the
source
code,
whether
it
was
Microsoft
or
Google
or
Facebook,
or
whatever
strong
naming
doesn't
do
that
strong
gaming
is
really
just
you
can
think
of
it
as
a
gooood
attached
to
your
assembly
name
and
it
was
used
to
locate
assemblies
in
the
GAC,
and
you
know
a
low
side
by
side,
loading
and
blah
blah
blah,
and
so
that
was
the
thing.
Why
was
originally
invented
now
there's
two
major
aspects
with
strong
enemy
that
you
should
be
aware
of.
A
One
of
them
is
it's
viral.
If
your
library,
a
strong
name
signed,
you
can
only
reference
things
that
are
strong
name
signed.
The
second
problem
is
removing
or
adding
a
strong
name
is
a
binary
breaking
change
because
it
changes
the
identity
of
your
library.
So
if
your
ship,
a
liar,
you
need
to
decide
upfront
whether
you
ever
wanted
strong
in
sandals
or
not.
There
are
some
open
source
libraries
that
went
the
road
where
they
published
to
NuGet
packages.
A
One
signed
one
unsigned
I,
don't
recommend
that
because
it
basically
Forks
the
ecosystem,
you
have
to
decide
which
you
know
which
graph
you
want
to
depend
on,
and
it's
generally
not
a
good
experience.
We
generally
recommend
that
you
know
if
you
build
an
open
source
library
that
you
expect
to
work
on
dotnet
framework.
You
should
strong
name
sign
it
from
day,
one
now
people
always
say.
Oh
then
I
have
to
maintain
keys.
All
of
that
and
the
recommendation
that
we
now
have
is
just
check
in
the
public
and
private
key.
A
The
private
keys
should
be
checked
in,
and
why
is
that?
Because
we
don't
want
to
care
about
strong,
aiming
for
security
reasons.
We've
set
this
guidance
for
over
ten
years
now.
Don't
use
strong
naming
to
make
a
security
security
decisions,
so
checking
in
the
private
key
is
fine,
it's
literally
just
it
good
attached
to
the
name.
That's
how
I
should
think
about
strong
in
me
and
that's
basically,
all
that
is
to
say
about
strong
naming
the
other
topic
that
always
triggers
people.
A
You
know
sending
me
almost
like
death
threats,
I
would
say
it's
like
fighting
redirects
and
that's
I.
Think
the
only
thing
really
where
I
would
say.
If
I
had
a
time
machine
that
could
go
back
to
net
v1,
that's
the
one
thing
I
would
probably
change
so
binding.
Redirect
first
of
all
is
donate
framework.
Only
so
any
other
don't
need
a
platform
that
has
shipped
since
then
you
know
Silverlight,
don't
need
core
mono,
you
WP
unity.
None
of
these
have
problems
with
mining
redirects.
A
So
if
you
complain
about
binding
redirects,
rest
assured
that's
the
thing
that
you
never
have
to
deal
with
unless
you
target
dotnet
framework
and
basically
what
it
does
is
the
London
framework
assembly
Laura
is
very
picky
if
you're
built
for
1.00
and
you
deploy
a
101
or
one
one
or
two.
Oh,
it
doesn't
matter.
If
the
version
numbers
don't
match
it
will
really,
it
will
reject
the
load
by
default.
Now
you
can
tell
the
system
to
say
yep.
A
A
And
so
I
have
a
library,
I
have
a
very
simple
thing
here
that
just
consumes
our
I'm.
Actually
we
built
this
guy
first
waist
when
you
get
packages
so
I
have
this
console
app
here
that
consumes
our
fabric
and
longing
library
we
showed
earlier
and
it's
very
innocent
it.
Just
you
know:
users
login
library,
locks
and
that's
it.
So
if
you
run
this
guy,
it
just
works
blocks
out
everything's
fine.
Now
we
do
something
fairly
innocent.
We
just
say
you
know
what
I
would
like
to
install
Jason
Burnett.
A
So
let
me
go
to
the
you:
go
to
work,
feed,
select,
Jason,
Garnett
yep,
let's
say
stable
version
is
fine,
install
and
now
I
control,
the
5
T
app,
and
now
you
get
this
little
thing
here.
Could
nerd
load
file
or
assembly
Microsoft
JSON
version
9?
And
if
you
read
further
on
it,
says
the
located
assembly,
manifest
definition
does
not
match
the
assembly
reference.
So
let
me
show
you
what
that
means.
If
you
go
to
the
output
folder
here
of
the
application,
let
me
launch
I'll
spy.
A
Mean
kill
everything
that's
in
here
and
just
bring
in
to
once
we
care
about
so
our
demo
and
then
our
our
logging,
library
and
Jason
dotnet,
which
we
can
find
under
n,
even
soft
Jason.
So
when
we
look
at
the
the
logging
library
here,
the
logging
library
has
a
reference
to
Newton
soft
Jason,
but
what
it
references
here
is
the
9
over.
A
If
we
look
at
our
demo
application
that
also
references
Newton's
of
Jason
actually
doesn't
right
now,
but
point
being
is
that
we
deploy
a
Newton
soft
Jason,
but
the
version
we
deploy
is
the
11
o
version.
As
you
can
see
here,
and
so
9
o
was
referenced.
11
all
was
deployed,
so
dotnet
says
by
default.
Nana
they're
not
same
thing,
so
I'm
not
going
to
load
that
now
you
can
manually
hack
your
app
config
file
to
include
this
binding.
Redirect
I
would
not
recommend
that,
because
you
know,
XML
is
ugly
and
hard
to
get
right.
A
So
what
you
can
do
instead
is
you
can
do
two
properties,
and
we
have
this
new
fancy
thing
here.
All
the
generate,
binding
redirects.
All
you
have
to
do
is
check
that
box
by
the
way
that
checkbox
is
set
by
default.
If
you
target
anything
higher
than
donate
framework
for
5-1
in
the
template,
that
is
so.
You
should
be
on
by
default
for
most
people,
if
it's
not
it's
just
the
check
box
away.
Now,
if
I
build
this
guy,
let
me
do
one
thing
as
well:
I
mean
we
target
this
app
to
for
72.
A
A
Well,
not
really
much,
but
a
little
bit
cleaner,
I
guess.
I
know
if
you've
run
the
application,
it
just
works.
Fine,
and
if
you
look
into
this
application
here,
the
config
file
that
we
deployed
actually
has
the
binding
redirect
for
for
a
JSON
11,
oh,
but
it's
fully
automatic.
So
that
means,
if
I
go
back
here
and
change
my
mind
on
which
version
of
Jason
I
want
to
use.
A
If
I
now
say
you
know
what
I
actually
want
to
use
to
the
Tenno
version
and
you
rebuild,
then
you
see
that
the
binding
redirect
is
now
updated
to
10.
Oh,
so,
basically,
that's
the
reason
why
I
should
use
automatic,
binding
redirects
are
not
in
framework,
because
you
don't
have
to
deal
with
that
and
even
better
if
you
target
anything
but
don't
enter
a
Mac.
You'd
never
have
to
be
above
my
knee
be
direct,
because
the
runtime
just
will
accept
any
version
number
that
is
higher
than
what
you
referenced
by
default,
all
right,
versioning.
A
So
versioning
is
this
thing
that
people
always
are
confused
about
as
well
they're
effectively
for
version
numbers
that
you
should
be
aware
of.
As
a
library
author
there's
the
packaged
version,
which
is
the
version
of
your
NuGet
package,
there
is
the
assembly
version,
which
is
the
version
number
of
the
DLL
itself.
That
net
sees
there's
the
file
version
as
the
informational
version.
The
first
two,
the
packaged
version
is
in
the
assembly
version
our
dotnet
concepts.
They
only
makes
sense
when
you
boot
or
net
libraries.
A
The
other
two
are
also
windows
concepts.
So
any
windows
PE
file
has
a
file
version
in
it
and
what
usually
ends
up
happening
is
when
you
install
binaries
setups,
we'll
also
consider
the
file
version
when
they
decide
which
file
is
newer
than
which
other
file.
So,
as
a
rule
of
thumb
package
version,
you
have
to
update
with
any
change,
because
only
one
version
can
be
on
you
can
org.
So
we
need
to
increment
that
anyway,
file
version
is
the
thing
you
should
increment
every
single
time.
A
You
make
a
change,
because
otherwise,
when
some
people
deploy
your
things
with
setups,
they
make
it
funky
behavior.
If
the
version
stays
the
same
on
the
assembly
version,
you
have
choice,
you
can
basically
say
screw.
It.
I
only
have
1.0,
but
never
touch
this
ever
again,
so
I
don't
have
to
live
with
binary
vector
under
that
framework.
I
generally
recommend
against
that
I
would
just
say
for
your
own
sanity.
I
would
I,
would
tie
assembly
version
and
file
version
and
keep
them
in
lockstep
and
automatically
update
them.
Every
single
time
you
make
a
change.
A
The
informational
version
is
a
string.
You
can
decide
whatever
you
want
to
put
there
like,
git
sha-1
hashes
are
usually
good
thing
to
put
there
because
then
you
can
tell
by
just
opening
the
file
in
Windows
Explorer
by
clicking
properties.
You
can
see
whether
whether
further
file
came
from,
but
that
is
tedious.
So,
let's
talk
about
ways
you
can
automate
that
so
for
this
I
also
have
a
demo,
which
will
be
the
thing
I
will
say
today
quite
often,
and
so
we
have
our
logging
library
again
like
nothing
magic
here.
A
A
A
I'm
gonna
show
what
these
settings
are
outdated,
but
the
point
is:
if
I
go
in
here,
you
can
decide
you
want
to
have.
This
is
the
packaged
version
you
want
to
have
one
two
three
and
I
want
to
have
a
three
or
version,
and
you
want
to
have
an
assembly
version
of
you
know
two
point
one
one,
one
whatever
you
can
decide
to
put
them
whatever
you
want
now.
If
you
know
edit
your
project
file,
you
will
find
out
that
nothing
happened
and
that
is
probably
because
I'm
running
on
stale
bits.
A
Let
me
do
one
thing
really:
quick
demo
for
the
demo
for
the
movie
I
was
demo
for
good.
He
said
origin/master
hard,
just
basically
wait
to
say,
oopsy-daisy,
let's
go
back
to
ever
used
to
be
perfect,
so
now
we're
we're
in
the
same
state
for
the
demo
and
no
that
looks
much
much
better.
What
I
expected?
Okay,
so
three
year
old,
four,
oh,
it's
safe,
go
to
the
project
file
and
little
surprises
there,
they're
just
persisted
in
the
project
file.
A
Now,
if
you
want
to
tie
them
to
each
other,
it's
very
simple:
all
you
have
to
do
is
use
Emmett's
built.
You
can
just
say
you
know
what
I
want
this
version
to
be
the
same
as
this
version.
So
all
you
do
here
is
basically
stuff
like
that.
So
no
real
surprises
there.
Now
again,
how
do
you
increment
the
version
numbers?
No,
that's
that's
the
real
killer.
You
don't
want
it
every
time
you
ship
remember
to
go
into
this
file
and
do
a
plus
one
manually
right.
A
A
It's
super
neat,
it's
done
by
a
definite
Visual,
Studio
and
who
are
not,
and
it's
super
neat,
because,
basically,
what
it
does
is
it
computes
the
build
number
for
you
and
when
you
know,
go
to
the
output
folder,
you
see
that
we
now
have
I
mean
just
clean
them
all
out,
build
them
in
here.
So
now
we
produced
the
101.
Now,
let's
say
I
make
a
change
to
my
library.
Let's
say
I
add
another
method
here
you
know.
A
A
You
know
it
just
yet
same
behavior,
so
I
highly
recommend
doing
something
like
that.
Of
course
it's
a
mess,
but
you
can
do
whatever
you
want.
You
can
have
your
own
scheme
date
scheme.
Whatever
you
want
to
do.
Point
being
is
increment
your
version
numbers
in
the
same
way,
and
you
will
be
better
off
all
right
now.
Let's
talk
a
little
bit
about
tips
and
tricks
in
general.
A
There's
a
few
websites
I
would
like
to
show
you
first
of
all
a
question
that
I
get
pretty
much
all
the
time
is,
is
API
X
or
Y
in
dotnet
standard
or
in
which
version
of
the
standard
was
it
introduced?
You
can
use
the
docs
for
that
and
the
docs
work
extremely
well
for
that
as
well,
but
I've
written
this
website,
because
it's
so
much
faster
I
can
say
path,
don't
join.
For
example,
pick
the
one
and
I
immediately
see
path
to
join
is
only
available
in
dotnet
core
3.0.
A
You
see
it
introduced
Internet
court
100,
then
FM,
you
can
see
the
assembly
is
there
in,
and
so
you
basically
get
immediately
the
history
of
the
particular
API.
So
it's
super
convenient
to
quickly
see
what
an
API
is
in
the
standard.
There's
also
other
data.
We
expose
your
like,
for
example,
how
popular
is
the
API
and
you'll
get
org?
How
popular
is
it
with
API
poured
the
tool
that
you
guys
all
keep
running
to
check
whether
you're
compatible,
and
so
this
is
a
very,
very
quick
way
to
check
things.
A
The
other
website
that
you
should
know
is
source
dotnet.
So
let's
say
you
want
to
find
the
implementation
of
path
to
join
and
by
implementation.
I
believe
mean
the
dotnet
core
implementation,
and
so
you
merely
can
click
here.
You
can
see
that
this
guy
just
does
join
internal
and
then
discuss
some.
You
know
amazing
things
to
do
it
in
the
fast
way.
We
also
have
source
off
dart
net,
which
is
the
dotnet
framework
source
Explorer.
A
So
if
you
wanted
to
see
how
path
toward
combined
Brooks
on
got
and
framework,
you
go
here
and
then
same
thing,
you
see
the
implementation.
Here,
you
can
click
on
things.
You
can
navigate
the
source
code.
You
can
find
usages.
It's
it's
a
pretty
rich
experience
to
quickly
navigate
around
to
see
how
things
work,
because,
as
implicational
library
also,
you
very
often
have
to
work
around
bucks.
A
We
have
to
understand
how
things
work
and,
in
the
past,
what
we
have
all
done,
this
open
up,
reflector
or
I'll
spy
and
disassembled
the
framework,
but
this
is
a
way
faster
way
to
navigate
the
source
code
of
the
dotnet
implementations
and
then
figure
out
why
things
work
the
way
they
do
or
not
or
not.
For
that
matter,
there's
another
one
that
you're,
probably
all
aware
of
which
is
nougat.
Org.
Alright,
no
surprises
here,
but
let's
say
I
want
to
I
want
to
see
the
API
it's
right.
A
So
if
I
go
to
collections,
immutable,
for
example,
great
here
are
the
types
that
are
in
there.
But
you
know
what
members
are
on
the
type
and
all
you
have
to
do
here
is
instead
of
saying
you
get.
You
say
you
get
Fugit
I,
don't
know
how
to
pronounce
that
you
go
there
and
it's
a
website
written
by
our
friend,
Frank
Krueger,
who
is
a
very
passionate
developer
and
it's
effectively
a
mirror
of
Newgate.
So
what's
cool
is
website?
Is
you
can
actually
browse
the
the
contents
of
the
assemblies?
You
can
see?
A
Oh
that's
a
mutable
namespace,
that's
an
immutable
set
and
here's
the
API
service
of
those
guys,
but
even
better
you
can
do
different.
You
can
say:
okay,
how
does
the
current
version
of
one
five
differ
from
the
one
one?
Thirty
one
boom
you
get,
the
actual
deform
watch
api's
got
editor
in
or
renamed
or
removed.
So
it's
a
super
convenient
way.
The
other
thing
is,
it
also
shows
you
which
platforms
things
are
supported
on,
in
this
case
its
targets
nesting
at
101,
one
so
our
1,
3
and
200,
and
also
portable.
A
A
So
what
I
have
now
here
is
me
just
quickly
go
here,
so
how
many
of
you
have
this
problem
that
when
you
have
a
large
solution
with
many
projects
that
you
want
to
lock
in
the
versions
of
packages
you
are
using
and
so
what
ends
up
happening
here?
Is
you
have
a
props
file
directory
the
Builder
props,
which
is
automatically
imported
into
every
project?
A
So
you
can
just
say
here's
my
version
number
for
Myka,
Sabrina's
compatibility,
here's
my
JSON
version
use
Mac's
unit
version
and
then
what
you
can
do
in
the
individual
project
you
can
just
say
instead
of
using
the
version
number
here,
you
just
say,
use
this
version
number
here.
What's
even
cooler
is
there
is
this
targets
file
where
you
would
place
packages,
for
example,
so
I
can
say
well,
let
me
actually
switch
to
XML.
It
might
be
easier
to
read.
A
Yeah
it
automatically
references
external
because
that's
what
I
said
in
the
targets
file,
so
the
nice
thing
with
these
targets
is
that
they
are
automatically
imported.
So
basically,
you
have
a
bunch
of
XML
or
msbuild
XML
that
is
automatically
available
to
all
your
projects.
So
this
is
where
you
can
centralize
effectively
things
like
you
know:
what's
you
copy
right
right?
What's
your
what's
your
website
or
what
is
the
thing
sign?
Is
it
not
signed
blah
blah
blah
and
if
it's
not
tested,
then
automatically
produce
a
new
get
package?
A
So
there's
a
whole
bunch
of
things
you
can
automate
away
by
just
using
these
two
magic
files,
they're,
also
not
trying
to
donate
family
to
donate
center.
They
also
available
for
any
project.
Really,
it's
just
an
MS
build
feature
that
works
everywhere.
So
if
you
do
anything
with
MS
built
today-
and
you
are
because
building
that
project,
you
should
take
a
look
at
that
super
super
neat.
A
Alright.
So
let
me
summarize
the
best
practices
all
up
for
building
class
libraries
there's
this
implicit
one,
which
we
don't
talk
about
much
anymore,
which
is
the
API
design
guidelines.
This
is
book
on
Amazon.
You
can
buy
in
family
design
guidelines
written
by
member
on
my
team
that
talks
about
naming
and
many
other
things
that
you
should
be
aware
of
as
a.net
developer,
but
in
essence,
what
you
should
do
is
you
should
design
your
API?
It's
right,
that's
the
minimum
thing.
I
think
everybody
wants.
A
The
second
thing
is:
do
target,
don't
ascend
a
2.0
if
you're,
starting
with
new
libraries,
just
target
2.0
and
you're,
probably
pretty
pretty
good,
to
go
for
a
long
time.
You
should
consider
multi
targeting,
especially
when
you
have
customers
under
10
framework
461
to
make
their
lives
better.
You
should
definitely
use
new
get
to
package
up
live
visit,
a
multi
targeted
so
that
nobody
has
to
select
the
right
binaries.
You
should
use
tough
I'm,
not
supported
for
API
is
you
cannot
support
everywhere,
and
you
should
offer
capabilities
API.
A
So
in
those
cases
when
that's
necessary
and
the
lastly
strong
name,
your
libraries
just
do
it
the
hosts
better
off.
We
have
much
much
less
problems.
Alright,
so
you're,
the
two-year-olds
you
should
remember
an
external
FAQ
is
the
one
that
I
keep
updating.
Whenever
questions
up
from
that
standard
and
then
I
have
to
donate
Senate
Doc's,
which
points
you
to
the
documentation
pages
and
I
thought
we
had
some
time
for
questions,
but
apparently
can
only
see
any
questions
if
the
website
is
not
displaying
a
little
on
the
teleprompter
anymore.