porges » csharp

Things I’d like to see in C#: Conditional interface implementation

Porges — Sat, 20 Sep 2008 02:54:29 +0000

To explain this, imagine you are designing a type Wrapper, which is just a simple wrapper around a type T.

class Wrapper<T>
{
    T value;
    public Wrapper(T theObject)
    {
        value = theObject;
    }
    // Some other methods...
}

Now, since this is a just a wrapper around some type T, we would like to implement some simple interfaces around this object. For example, if T is comparable, we would like the wrapper class to implement IComparable>. However this is not possible with C#. In Haskell we would have something like this:

instance (Disposable a) => Disposable (Wrapper a) where ...

This says “if a is a type that is an instance of Disposable, then the type Wrapper a is also an instance of Disposable”. In C#, I’d like to see something like this:

class Wrapper<T>
    : IComparable<Wrapper<T>>
        when T : IComparable<T> //this is the syntax extension
{
    //...
}

And then in any methods that the interface specifies (in this case int Compare(Wrapper other)), it is assumed that for any object of type T you have access to all the methods that T has when it implements IComparable.

At the moment the best you can do is to always implement IComparable> and just throw a runtime exception when T doesn’t implement IComparable, which isn’t very nice.

A simple idea, but it would add great power to C#.

After some (very quick) research I haven’t found anything that suggests anyone else has attempted to get this into C#, but there is JavaGI (see section 2.4 for the equivalent of what this post talks about) where the authors have extended Java to deal with what they term ‘generalized interfaces’—a concept which alters Java (rather radically) to make interface implementations similar to Haskell’s typeclasses.

Implementing IEnumerable easily

Porges — Fri, 04 Apr 2008 09:43:02 +0000

Say that you’re implementing a linked list, and you want an enumerator:

public IEnumerator<T> GetEnumerator()
{
    return new Stream<T,Node>(first,
        node => node.next == null ? null : Tuple.Of(node.next, node.datum).AsNullable());
}

This uses the following utility class to implement the enumerator in one line (along with some code for Tuples and an extension method for structs):

public class Stream<Tdata, Tstate> : IEnumerator<Tdata>
{
    private Tdata current;
    private Tstate initialState;
    private Tstate state;
    private Func<Tstate, Pair<Tstate, Tdata>?> moveNext;
 
    public Stream(Tstate initialState, Func<Tstate, Pair<Tstate, Tdata>?> calcNextValue)
    {
        moveNext = calcNextValue;
        this.initialState = initialState;
        Reset();
    }
 
    #region IEnumerator Members
 
    public Tdata Current
    {
        get { return current; }
    }
 
    #endregion
 
    #region IDisposable Members
 
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
 
    protected void Dispose(bool disposing)
    {
        if (disposing)
        {
            var disposeCurrent = current as IDisposable;
            if (disposeCurrent != null)
                disposeCurrent.Dispose();
 
            var disposeState = state as IDisposable;
            if (disposeState != null)
            {
                disposeState.Dispose();
                //safe; have checked already above.
                //type of state == type of initialstate
                ((IDisposable)initialState).Dispose();
            }
        }
    }
 
    #endregion
 
    #region IEnumerator Members
 
    object System.Collections.IEnumerator.Current
    {
        get { return current; }
    }
 
    public bool MoveNext()
    {
        var result = moveNext(state);
 
        if (result.HasValue)
        {
            current = result.Value.Right;
            state = result.Value.Left;
            return true;
        }
        else
            return false;
    }
 
    public void Reset()
    {
        state = initialState;
    }
 
    #endregion
}

object.Equals handles null values correctly

Porges — Thu, 27 Mar 2008 20:58:12 +0000

Here’s the source code, as disassembled by Reflector:

public static bool Equals(object objA, object objB)
{
    return ((objA == objB) || (((objA != null) && (objB != null)) && objA.Equals(objB)));
}

It seems that not even Microsoft knows this! I spotted this code, from ASP.NET’s MVC implementation, on Scott Hanselman’s blog:

return (other != null) &&
  (((other._first == null) && (_first == null)) ||
    ((other._first != null) && other._first.Equals(_first))) &&
  (((other._second == null) && (_second == null)) ||
    ((other._second != null) && other._second.Equals(_second)));

This can be rewritten as:

return (other != null) &&
  object.Equals(other._first, _first) &&
  object.Equals(other._second, _second);

Much nicer!