Is it possible to create constructor-extension-method ? how?

Is it possible to add a constructor extension method?

Sample Use Case

I want to add a List< T > constructor to receive specific amount of bytes out of a given partially filled buffer (without the overhead of copying only the relevant bytes and so on):

...
public static List<T>(this List<T> l, T[] a, int n)
{
    for (int i = 0; i < n; i++)
       l.Add(a[i]);
}
...

so the usage would be:

List<byte> some_list = new List<byte>(my_byte_array,number_of_bytes);

I've already added an AddRange extension method:

public static void AddRange<T>(this List<T> l, T[] a, int n)
{
   for (int i = 0; i < n; i++)
       l.Add(a[i]);
}

I want to do it as a constructor too. Is it possible? If yes - how?

No, but if you changed your AddRange signature to return the list instance, then you could at least do

var list = new List<int>().AddRange(array, n);

which imho is probably clearer than overloading the constructor anyway.

SWeko's answer is basically correct, though of course the article he links to is about extension properties rather than extension constructors.

We also did a rough design for extension constructors at the same time as we did extension properties; they would be a nice syntactic sugar for the factory pattern. However, they never got past the design stage; the feature, though nice, is not really necessary and does not enable any awesome new scenarios.

If you have a really awesome problem that extension constructors would solve, I'd be happy to hear more details. The more real-world feedback we get, the better we are able to evaluate the relative merits of the hundreds of different feature suggestions we get every year.

In a word - no. Take a look at this for some explanation.

They were cut from the C# 3 feature list, then they were cut from the C# 4 feature list, and we can only hope that they could make the C# 5 features, but I'm not very optimistic.

I know this is a bump, just wanted to point out you can inherit the List class and do something like this:

class List<T> : System.Collections.Generic.List<T>
	{
		public List(T[] a, int n)
			: base()
		{
				AddRange(a, n);
		}
	}

Yes-ish but no?

MyClass{
   public MyClass(params){ //do stuff };
   public MyClass MyConstructorAddOn(moreParams){ //do more stuff; return this;}
}

then call this way:

MyClass(params).MyConstructorAddOn(moreParams); 

It works a bit like an extension method. Although NOT a constructor, it can be used as a daisy chain on a constructor to do more stuff outside of the constructor immediately. I believe this is called fluent interfaces.