Say I have generic value wrapper:

```
class Wrapper<T>
{
    public T Value { get; set; }
}

```

And I'd like to use it as listed below (or something like this):

```
var wrapper = new Wrapper<Target>();
// ...
Target target = wrapper;

```

How is it possible using implicit operator, extension method or another approach to provide single-place null checking? As one of benefits I want to keep the following code in the single place:

```
if (wrapper != null)
{
    return wrapper.Value;
}

return default(T);

```

**EDIT:**

I tried the operator:

```
public static implicit operator T(Wrapper<T> wrapper)
{
    return wrapper.Value ? default(T) : wrapper.Value;
}

```

It's perfectly works I the way below:

```
var wrapper = new Wrapper<long>();
long value = wrapper;

```

But fails on:

```
var wrapper = new Wrapper<IEnumerable<long>>();
IEnumerable<long> value = wrapper;

```

Compiler says it is not possible to convert from `Wrapper<IEnumerable<long>>` to `IEnumerable<long>`. Any ideas?