P>class Ticket
P>{
P>  public Ticket(int id) {}
  
P>  public static Ticket InitTicket(int id) {}

P>  public static explicit operator Ticket(int id) {}
P>}
P>

class TicketFactory//TicketController, TicketManager, TicketDAL и т.п по желанию
{
Ticket TicketFactory::CreateTicket(int id)
Ticket LoadTicket(int id)
}

P>class Ticket
P>{
P>  public Ticket(int id) {}
  
P>  public static Ticket InitTicket(int id) {}

P>  public static explicit operator Ticket(int id) {}
P>}

class Ticket
{
  public Ticket(int id) {}
  
  public static Ticket InitTicket(int id) {}

  public static explicit operator Ticket(int id) {}
}

P>class Ticket
P>{
P>  public Ticket(int id) {}
  
P>  public static Ticket InitTicket(int id) {}

P>  public static explicit operator Ticket(int id) {}
P>}
P>

 class Ticket 
{
  public static Ticket* instance(int id) {}
}

 Ticket *t = Ticket::instance(id);

class T {
public:
    T (int i): 
        m_i(i) {};

    int value() const {return m_i; };
private:
    int m_i;
};

const T& func(const T& val)
{
    int vali = 10;

    return vali;
}


//
int main ( int, char ** ) {
    T v(1);
    std::cout << "value: " << func(v).value() << std::endl;
}

List<T>()
List<T>(IEnumerable<T>)
List<T>(Int32)

I>List<T>()
I>List<T>(IEnumerable<T>)
I>List<T>(Int32)

_FR>А какие возникают сомнения?

List<T>(Int32)

_FR>>А какие возникают сомнения?

I>List<T>(Int32)

MyStringCollection(IEnumerable<string>)
MyStringCollection(int n) // n пустых строк
MyStringCollection(TextReader) // читает построчно
MyStringCollection(File) // читает построчно

I>>MyStringCollection(IEnumerable<string>)
I>>MyStringCollection(int n) // n пустых строк
I>>MyStringCollection(TextReader) // читает построчно
I>>MyStringCollection(File) // читает построчно

I>О чем я и говорил — двух последних конструкторов не должно быть, более того, и статического метода тоже быть не должно

А значение Capacity обязано "хранятся потом в самом объекте"? Это ведь дело реализации, можно ведь и пройти список и посчитать.

List<T>()

List<T>(IEnumerable<T>)

List<T>(Int32)

Семантика такая: конструктор — это метод, в который передаётся некоторое "начальное" состояние объекта

_FR>>Я прошу тебя высказать твоё собственное мнение. Почему ты даёшь ссылку на пост другого человека?

I>Хорошо, господин учитель.

IEnumerable<string> items = GetItems();
List<string> list = new List<string>(items);

_FR>>Покажи мне место в том, что ты называешь "правилом Фреда", где бы говорилось хоть что-нибудь о то, что "полностью описывает состояние объекта" Нигде я ничего подобного не говорил.

void Test(MyBusinessEntitiesCollection<MyEntity> items) {
  var list = new List<MyEntity>(items);
  var collection = new Collection<MyEntity>(items);
}

void Test(MyBusinessEntitiesCollection<MyEntity> items) {
  var list1 = items.ToList(); // "To" - значит скопировали
  var list2 = List.Create(items);
  var collection = new Collection<MyEntity>(items);
  var collection2 = items.AsMyDecorator(); // "As" - обернули
}

Остается первый конструктор к которому ты не написал комментария, если он такой же, как и List<string>(IEnumerable<string>) то все в порядке.

здесь

Автор: Ikemefula
Дата: 25.04.10

Поэтому конструктор List<T>(IEnumerable<T>) является практически аналогом конструктора копирования в С++.

здесь

Автор: GlebZ
Дата: 26.04.10

var list = new List<X>(5);

var list = new List<X>() { Capacity = 5, };

        public static List<T> Create<T>(IEnumerable<T> source)
        {
            if (source == null)
            {
                throw new ArgumentNullException("source");
            }

            var collection = source as ICollection<T>;
            var list = (collection != null) ? new List<T>(collection.Count) : new List<T>();
            foreach (var item in source)
            {
                list.Add(item);
            }
            return list;
        }

_FR>        public static List<T> Create<T>(IEnumerable<T> source)
_FR>        {
_FR>            if (source == null)
_FR>            {
_FR>                throw new ArgumentNullException("source");
_FR>            }

_FR>            var collection = source as ICollection<T>;
_FR>            var list = (collection != null) ? new List<T>(collection.Count) : new List<T>();
_FR>            foreach (var item in source)
_FR>            {
_FR>                list.Add(item);
_FR>            }
_FR>            return list;
_FR>        }

        static void checkSource(source) {
            if (source == null)
                throw new ArgumentNullException("source");
        }

        static List<T> fillList(IEnumerable<T> source, List<T> list) {
            foreach (var item in source)
                list.Add(item);
            return list;
        }

        public static List<T> Create<T>(IEnumerable<T> source) {
            checkSource();
            return fillList(source, new List<T>());
        }

        public static List<T> Create<T>(ICollection<T> source) {
            checkSource();
            return fillList(source, new List<T>(source.Count));
        }