Wie können fertige Shims für die Portierung von .NET Framework auf .NET Core/Standard erstellt oder verwendet werden?

Im Folgenden sind zumindest zufriedenstellende Ansätze:

Danke Firda aus Tschechien. Das ist seine Antwort

1) Generisches Shim ist genug für mich (Schnipsel können helfen)

public abstract class Shim<TImpl>
{
    internal TImpl It { get; }
    protected Shim(TImpl it) { It = it; }
}

BEISPIEL:

public class DispatcherPriorityShim : Shim<
#if NETFULL
    DispatcherPriority
#Elif NETCORE
    string
#endif
>
{
    public DispatcherPriorityShim(string it)
#if NETFULL
        : base((DispatcherPriority)Enum.Parse(typeof(DispatcherPriority), it))
#Elif NETCORE
        : base(it)
#endif
    { }
}

Meine sdk-style .csproj-Datei zum Verdeutlichen von NETFULL und NETCORE:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup><TargetFrameworks>netstandard2.0;netcoreapp2.0;net461</TargetFrameworks></PropertyGroup>

  <PropertyGroup Condition=" '$(TargetFramework)' == 'netcoreapp2.0' OR '$(TargetFramework)' == 'netstandard2.0'">
    <DefineConstants>NETCORE;</DefineConstants></PropertyGroup>

  <PropertyGroup Condition=" '$(TargetFramework)' == 'net461'">
    <DefineConstants>NETFULL;</DefineConstants></PropertyGroup>
</Project>

1.a) Visual Studio Schnipsel

drv

#if NETFULL

#Elif NETCORE

#endif

shimenum

namespace PortabilityLibrary.Shims
{
  public class $enumname$Shim : Shim<
#if NETFULL
    $enumname$
#Elif NETCORE
    string
#endif
>
  {
        public $enumname$Shim(string it)
#if NETFULL
        : base(($enumname$)Enum.Parse(typeof($enumname$), it))
#Elif NETCORE
          : base(it)
#endif
        { }
  }
}

shimsnip

namespace PortabilityLibrary.Shims
{
  public class $classname$Shim : Shim<
#if NETFULL
    $classname$
#Elif NETCORE
    $classname$
//NullObject
#endif
>
  {
        public $classname$Shim()
#if NETFULL
        : base(new $classname$())
#Elif NETCORE
        : base(new $classname$())
    //: base(new NullObject())
#endif
        {}
  }
}

shimmeth

        public void $methodname$()
        {
#if NETFULL
        It.$methodname$();
#Elif NETCORE
        It.$methodname$();
        //throw new ShimException();
#endif
        }

shimprop - noch nicht

2) Fall, wenn Vererbung erforderlich ist.

public interface IShimOne
{
    void MethodOne();
}
public interface IShimTwo: IShimOne
{
    void MethodTwo();
}
#if NETFULL
class One: RealOne, IShimOne {}
class Two: RealTwo, IShimTwo {}
public static class ShimFactory
{
    public static IShimOne CreateOne() { return new One(); }
    public static IShimTwo CreateTwo() { return new Two(); }
}

2.a) Objekte zur Vererbung

public class WrapperOne
{
    protected IShimOne It { get; }
    protected WrapperOne(IShimOne it) { It = it; }
    public WrapperOne() { It = ShimFactory.CreateOne(); }
    public void MethodOne() { It.MethodOne(); }
}
public class WrapperTwo: WrapperOne
{
    protected new IShimTwo It => (IShimTwo)base.It;
    protected WrapperTwo(IShimTwo it): base(it) {}
    public WrapperTwo(): base(ShimFactory.CreateTwo()) {}
    public void MethodTwo() { It.MethodTwo(); }

3) Fertige "Gegenstücke" für GUI-Steuerelemente ( Eto.Forms )

(eigentlich hat Eto.Forms eine breitere Anwendung - sie sind die Unterlegscheiben)

Dieses Framework kann zum Erstellen von Anwendungen verwendet werden, die über mehrere Plattformen mit ihrem nativen Toolkit mit einer benutzerfreundlichen API ausgeführt werden. Dadurch werden Ihre Anwendungen als native Anwendung auf allen Plattformen mit einer einzigen UI-Codebasis aussehen und funktionieren ...

//Not fully implemented, just showing the idea:

#if NETFULL
using System.Windows.Controls;
#Elif NETCORE
using Eto.Forms;
#endif

namespace PortabilityLibrary.Shims
{
    public class MenuItemShim : Shim<
#if NETFULL
    MenuItem
#Elif NETCORE
    MenuItem
#endif
    >
    {
        public MenuItemShim(EventHandler<EventArgs> dlg)
#if NETFULL
        : base(new MenuItem(/*not implemented*/))
#Elif NETCORE
        : base(new ButtonMenuItem(dlg))
#endif
        { }
    }
}