Proposal: support "type of the current object" as declared return type.

[biqas]

public class Self
{
    public this Self1()
    {
        // Only allowed to return with keyword this.
        // Very important that only 'this' is allowed as returning value.
        return this;
    }

    public this Self2()
    {
        // NOT allowed.
        return new Self();
    }

    public this Self3()
    {
        // NOT allowed.
        return new Object();
    }
}

[jmarolf]

Could you give an example of how this would be useful? Unless I am misunderstanding, don't constructors fill this role today?

[manish]

What would be other significant use of this syntax apart from method chaining?

[biqas]

Maybe this one is giving more examples:
http://roslyn.codeplex.com/discussions/562656

[biqas]

@manish
that you can type safe method chain of same reference or derived ones!

[SolalPirelli]

Duplicate of #155, I think. An equivalent of Scala's this.type would be welcome indeed.

[McZosch]

The idea is pretty simple, I guess.

If you have a immutable base class A and a derived class B, and modifications are made through members in class A, those members always return A. If you want to apply the same modifications to type B without having to do a lot of casts, you need to overload any method within B.

So, the method definition needs to say [type of this], i.e. return [A] when instance is typed [A] and [B] when instance is typed [B].

Two problems:

First, if the method is only implemented in class A, it would need to be implemented type-agnostic to handle all thinkable derived types. It will quickly become a System.Activator.CreateInstance-party, with the compiler handling several variance issues. A performance nightmare coupled with unnecessary complexity.

Second, this feature is already delivered through extensions and type-constraints. This spreads your code over two classes, which is problematic for some coding styles. Maybe, we should be capable of using static class members as extensions.

[biqas]

@McZosch
Extension methods can't be overridden.

@gafter
Returning "type of the current object" is semantically different to returning "this" reference.

public class BaseClass
{
    public virtual this Foo()
    {
        return this;
    }
}

public class DerivedClass1 : BaseClass
{
    public override this Foo()
    {
        return this;
    }
}

public class DerivedClass2 : BaseClass
{
    public override this Foo()
    {
        // Is a valid call, because the "this" reference is returned.
        return base.Foo();
    }
}

Co-variant return types have different semantic.

class Compilation ...
{
    virtual Compilation WithOptions(Options options)
    {
        // the proposal is not allowing new object creation.
        return new Compilation();
    }
}

class CSharpCompilation1 : Compilation
{
    override CSharpCompilation1 WithOptions(Options options)
    {
        // the proposal is expecting CSharpCompilation as return type.
        return new CSharpCompilation1();
    }
}

class CSharpCompilation2 : CSharpCompilation1
{
    override CSharpCompilation1 WithOptions(Options options)
    {
        // the proposal is expecting CSharpCompilation2 as return type.
        return base.WithOptions(options);
    }
}

[Thaina]

Well... after some times I think we could just workaround with generic extension method

public class OurStringBuilder
{
    internal void Append();
}

public class OurStringBuilderExt
{
    public S Put<S>(this S sb,string s) where S : OurStringBuilder
    {
        sb.Append(s);
        return sb;
    }

    public S AppendLine<S>(this S sb,string s) where S : OurStringBuilder
    {
        sb.Append(s);
        sb.Append(Environment.NewLine);
        return sb;
    }
}

new OurStringBuilder().Put("s").Put("t").Put("r").Put("i").Put("n").AppendLine("g");

This is satisfied our need. It also work with interface on struct and everything. Also we could implement most logic in extension method instead of its base class

[Shadowblitz16]

What about returning a variable types?

Note this is not the way I would do it but its just a example..

    public class Node : I 
    {
        internal Node       _parent;
        internal List<Node> _children = new List<Node>();

        public _parent.GetType() GetParent()
        {
            return _parent;
        }
        public _children[n].GetType() GetChild(int n)
        {
            return _children[n]
        }

Returning this only works if the method is in the current class

[biqas]

@Shadowblitz16
this would defeate the purpose of the proposal.