如何编写包装器类以使用部分泛型类型推断

本文关键字：用部 泛型类型 何编写 包装 | 更新日期: 2023-09-27 17:49:36

这与这个问题有关。

我想创建一个通用包装器类:

public abstract class Wrapper<T>
{
    internal protected T Wrapped { get; set; }
}

具有以下扩展名:

public static class WrapperExtensions
{
    public static W Wrap<W,T>(this T wrapped) where W:Wrapper<T>,new()
    {
        return new W {Wrapped = wrapped};
    }
    public static T Unwrap<T>(this Wrapper<T> w)
    {
        return w.Wrapped;
    }
}

现在假设一个具体的包装器:

public class MyIntWrapper : Wrapper<int>
{
    public override string ToString()
    {
        return "I am wrapping an integer with value " + Wrapped;
    }
}

我想这样调用Wrap扩展:

MyIntWrapper wrapped = 42.Wrap<MyIntWrapper>();

这是不可能的，因为在c#中我们需要为Wrap扩展提供两个类型参数。(要么全部要么没有)

显然部分推理在f#中是可能的。

上面的代码在f#中看起来如何?

有可能在c#中使用它吗?

如何编写包装器类以使用部分泛型类型推断

显然部分推理在f#中是可能的。

是的，在您的示例中只需要指定W。T将被推断。


上面的代码在f#中看起来如何? 

[<AbstractClass>]
type Wrapper<'a>() =
    [<DefaultValue>]
    val mutable internal Wrapped : 'a
let Wrap<'W,'T when 'W :> Wrapper<'T> and 'W: (new: unit -> 'W)> (wrapped: 'T): 'W = 
    let instance = new 'W()
    instance.Wrapped <- wrapped
    instance
let Unwrap (w: Wrapper<_>) = w.Wrapped
type MyIntWrapper() =
    inherit Wrapper<int>()
    override this.ToString() = 
        sprintf "I'm wrapping an integer with value %d" this.Wrapped

你可以这样调用f#中的Wrap 

> let wrapped = Wrap<MyIntWrapper,_> 5;;
val wrapped : MyIntWrapper = I'm wrapping an integer with value 5

在我看来，这在f#中不是很习惯，我宁愿使用区分联合和模式匹配来进行包装/展开，但我不知道具体是什么情况。


可以在c#中使用吗?

当然，但是如果你从c#调用Wrap，你就回到了c#类型推断，并且必须指定第二个类型参数。

实现自定义隐式转换:

MSDN样本

struct MyIntWrapper
{
    public MyIntWrapper(int value) 
    {
        this.value = value; 
    }
    static public implicit operator MyIntWrapper(int value)
    {
        return new MyIntWrapper(value);
    }
    static public explicit operator int(MyIntWrapper wrapper)
    {
         return wrapper.value;
    }
    private int value;
}

你可以这样写:

MyIntWrapper wrapped = 42;

你可以在f#:

open System.Runtime.CompilerServices
type Wrapper<'T> =
  abstract Wrapped : 'T
[<Extension>]
module WrapperExtensions =
  [<Extension>]
  let Wrap wrapped = { new Wrapper<_> with member x.Wrapped = wrapped }
  [<Extension>]
  let Unwrap (w: Wrapper<_>) = w.Wrapped

然后在c#中像这样使用:

var wrapped = 42.Wrap();
wrapped.Unwrap();

这是你想要的吗?

您可以使用helper类将泛型参数分离为两个单独的调用，从而可以推断出您想要的那个。LinqPad示例:

void Main()
{
    MyIntWrapper wrapped = 42.Wrap().To<MyIntWrapper>(); 
}
public abstract class Wrapper<T>
{
    internal protected T Wrapped { get; set; }
}
public static class WrapperExtensions
{
    public static WrapHelper<T> Wrap<T>(this T wrapped) 
    {
        return new WrapHelper<T>(wrapped);
    }
    public static T Unwrap<T>(this Wrapper<T> w)
    {
        return w.Wrapped;
    }
    public class WrapHelper<T> 
    {
        private T wrapped;
        public WrapHelper(T wrapped) 
        {
            this.wrapped = wrapped;
        }
        public W To<W>() where W : Wrapper<T>, new() 
        {
            return new W {Wrapped = wrapped};
        }
    }
}
public class MyIntWrapper : Wrapper<int>
{
    public override string ToString()
    {
        return "I am wrapping an integer with value " + Wrapped;
    }
}

特别要注意新类WrapHelper<T>，它公开了方法To<W>。对于该方法，您传递了一个显式的泛型参数，但对于原始Wrap<T>方法，它由this T推断，返回该助手类的实例，允许您将方法调用链接在一起以获得所需的内容。

相关文章：