Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
How .NET Standard relates to .NET Platforms
using System;
namespace Analogy
{
// Each interface represents a target framework and methods represents groups of APIs available on that target framework.
// The goal is to show the relationship between .NET Standard API surface and other .NET platforms
// .NET Standard
interface INetStandard10
{
void Primitives();
void Reflection();
void Tasks();
void Collections();
void Linq();
}
interface INetStandard11 : INetStandard10
{
void ConcurrentCollections();
void InteropServices();
}
interface INetStandard12 : INetStandard11
{
void ThreadingTimer();
}
interface INetStandard13 : INetStandard12
{
void FileSystem();
void Console();
void ThreadPool();
void Process();
void Sockets();
void AsyncLocal();
}
interface INetStandard14 : INetStandard13
{
void IsolatedStorage();
}
interface INetStandard15 : INetStandard14
{
void AssemblyLoadContext();
}
// .NET Framework
interface INetFramework45 : INetStandard11
{
void FileSystem();
void Console();
void ThreadPool();
void Crypto();
void WebSockets();
void Process();
void Sockets();
void AppDomain();
void Xml();
void Drawing();
void SystemWeb();
void WPF();
void WindowsForms();
void WCF();
}
interface INetFramework451 : INetFramework45, INetStandard12
{
// TODO: .NET Framework 4.5.1 specific APIs
}
interface INetFramework452 : INetFramework451, INetStandard12
{
// TODO: .NET Framework 4.5.2 specific APIs
}
interface INetFramework46 : INetFramework452, INetStandard13
{
// TODO: .NET Framework 4.6 specific APIs
}
interface INetFramework461 : INetFramework46, INetStandard14
{
// TODO: .NET Framework 4.6.1 specific APIs
}
interface INetFramework462 : INetFramework461, INetStandard15
{
// TODO: .NET Framework 4.6 specific APIs
}
// Mono
interface IMono43 : INetFramework46
{
void MonoSpecificApi();
}
// Windows Universal Platform
interface IWindowsUniversalPlatform : INetStandard14
{
void GPS();
void Xaml();
}
// Xamarin
interface IXamarinIOS : INetStandard15
{
void AppleAPIs();
}
interface IXamarinAndroid : INetStandard15
{
void GoogleAPIs();
}
// .NET Core
interface INetCoreApp10 : INetStandard15
{
}
// Future platform
interface ISomeFuturePlatform : INetStandard13
{
// A future platform chooses to implement a specific .NET Standard version.
// All libraries that target that version are instantly compatible with this new
// platform
}
}
namespace Analogy
{
/// <summary>
/// This example shows that a library that needs access to target .NET Standard 1.3
/// can only access APIs available in that .NET Standard. Even though similar the APIs exist on .NET
/// Framework 4.5, it implements a version of .NET Standard that isn't compatible with the library.
/// </summary>INetCoreApp10
class Example1
{
public void Net45Application(INetFramework45 platform)
{
// .NET Framework 4.5 has access to all .NET Framework APIs
platform.FileSystem();
platform.Console();
// This fails because .NET Framework 4.5 does not implement .NET Standard 1.3
// Argument 1: cannot convert from 'Analogy.INetFramework45' to 'Analogy.INetStandard13'
NetStandardLibrary13(platform);
}
public void NetStandardLibrary13(INetStandard13 platform)
{
platform.FileSystem();
platform.Console();
}
}
/// <summary>
/// This example shows a library targeting multiple frameworks and 2 different applications
/// using that library. MultipleTargetsLibrary needs access to the FileSystem, that API was only available
/// in .NET Standard 1.3. .NET Standard 1.3 only works with .NET Framework 4.6. Because of this
/// MultipleTargetsLibrary needs to add support for .NET Framework 4.5 explicitly.
/// </summary>
class Example2
{
public void Net45Application(INetFramework451 platform)
{
// On the .NET 4.5.1 application, the INetFramework45 implementation is choson
MultipleTargetsLibrary(platform);
}
public void NetCoreApplication(INetCoreApp10 platform)
{
// On the .NET Core 1.0 application, the INetStandard13 implementation is choson
MultipleTargetsLibrary(platform);
}
public void MultipleTargetsLibrary(INetFramework45 platform)
{
platform.FileSystem();
}
public void MultipleTargetsLibrary(INetStandard13 platform)
{
platform.FileSystem();
}
}
/// <summary>
/// This example shows how future platforms can be added without the need to change libraries that
/// target the .NET Standard. JSON.NET targets .NET Standard 1.0 and can run on *ANY* platform that implements
/// the standard.
/// </summary>
class Example3
{
/// <summary>
/// This future platform implements .NET Standard 1.3
/// </summary>
public void FuturePlatformApplication(ISomeFuturePlatform platform)
{
// You are able to use JSON.NET with the future platform without recompiling JSON.NET
JsonNet(platform);
}
/// <summary>
/// This method represents the implementation of JSON.NET. JSON.NET supports .NET Standard 1.0.
/// </summary>
public void JsonNet(INetStandard10 platform)
{
platform.Linq();
platform.Reflection();
platform.Collections();
}
}
}
@valerysntx
Copy link

valerysntx commented Nov 20, 2016

👍

/* IComparable<SemVer>? */
public class INetStandard13: IComparable, IComparable<INetCoreApp10>, IEquatable 
{
}
 
      

@bitbonk
Copy link

bitbonk commented Nov 30, 2016

This could need an update for .NET Standard 1.6 and maybe 2.0, even if it is not fully baked yet.

@mossyblog
Copy link

mossyblog commented Dec 7, 2016

The part that still concerns me is the vNext parts.. the fork in the road... let us pick on async/await ... now it's a pretty prolific thing to use in most "modern" .NET code today, however, Unity3D / WebGL, currently can't support this approach to multi-threading... now sure, one can argue "well, sux to be Unity3d and the world moves forward" however, all this does really is cap off a fork in the road, as in order for this to realistically work it needs some incentive or forcing function that encourages all ships to rise with the future tides in a uniform way (no boat gets left behind)... so how does one concede defeat on some areas where it just can't be brought forward due to technical or commercial limitations (lets for argument sake, assert Unity3D can't make task/parallel work because it conflicts with their IL2CPP output) on larger platform adoptees - such as Unity3D ...iOS etc.

The point is there will be commercial realities to face with the platform and how one triages that IF/ELSE statement is where I'm a little gun-shy from PCL abuse.

@jorgensigvardsson
Copy link

jorgensigvardsson commented Dec 7, 2016

I find this very clear and concise. Thanks!

@Jasonlhy
Copy link

Jasonlhy commented Jan 13, 2017

This is what I got using "generate class diagram" in visual studio.

classdiagram1

@stg609
Copy link

stg609 commented Feb 9, 2017

It makes more sense now! Thanks!

@devenshah
Copy link

devenshah commented Feb 10, 2017

Click! Click!

@peponeska
Copy link

peponeska commented Feb 15, 2017

What about netstandard2.0?

@Noctis-
Copy link

Noctis- commented Mar 27, 2017

consider changing "choson" to "chosen" ? :)

@Kralizek
Copy link

Kralizek commented Apr 19, 2017

Really nice. I would suggest to use concrete classes to represent NetCoreApp10, NetCoreApp11 and the several .NET Frameworks like Net46 and Net47

@jsinh
Copy link

jsinh commented Jun 11, 2017

Makes sense, thanks!

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment