Schedule talks in tracks Consider my simple business requirement as follows:
There is a list of talks and they need to be scheduled in tracks. Each track has a morning session starting at 9am and an afternoon session starting at 1pm ending by 4pm and a lunch break from 12pm to 1pm.
Given: A list of talks - Talk.txt

Python session 90min
Java session 75min
Blender session 120min

When: I call by business implementation
Then: It gives the list of scheduled track

Track 1:
9:00am Python session
10:30am Java session
12:00pm Lunch
1:00pm Blender session

Now to approach this problem I want to design a contract that expect to return the final result. Besides I'm thinking some of the future (or possible) business requirement changes.

Presentation of the schedule has changed to &quot;Java session at 10:30am&quot;

In above expected output there is a gap of 15 mins between lunch and the previous talk

Perhaps the morning session's start time has changed to 10am


The simplest way to designing the contract that I have in my mind is:
public interface IScheduleTalk
{
    List&lt;string&gt; GetScheduledTalk(List&lt;string&gt; usrInput)
}

But it does not help me with the above problems, and then I have change the contract if any the requirement changes in above mentioned way. Besides it does not address the gap.
I went to redesign my contract and have come up with below two approaches:
1st being:
public class Track
{
    public int TrackNumber { get; set; }
    public Dictionary&lt;Slot, string&gt; ScheduledTalks { get; set; }
}

public class Slot
{
    public string ScheduledTime { get; set; }
    public int DurationInMin { get; set; }
}

public interface IScheduleTalk
{
    List&lt;Track&gt; GetScheduledTalk(List&lt;string&gt; talks); 
}

And the 2nd is:
public class Track
{
    public int TrackNumber { get; set; }
    public Dictionary&lt;string, Talk&gt; ScheduledTalks { get; set; } //Dictionary TKey represents the schedule time such as &quot;9:00am&quot;
}

public class Talk
{
    public int DurationInMin {get; set;}
    public string TalkName {get; set;}
}

public interface IScheduleTalk
{
    List&lt;Track&gt; GetScheduledTalk(List&lt;string&gt; talks); 
}

I need a suggestion which one should I use as the contract. Or if there is/are better way to do it.
I see what you are trying to achieve, while your question does not fully meet the Code Review rules, but I guess some inputs won't hurt specially in my free time ;). 

In my opinion, 


You should use DateTime instead of string and int. 
You should combine Talk and Slot, as it should be only one class that hold the meeting details (subject, time, and place ..etc).
You can use DurationInMin, but I would rather use DateTime and based on the business requirements, I would make a way to make the user input only integer while using DateTime in the back-end, (e.g. in the front-end, I make a field that only accepts int, and in the back-end, I call DateTime.AddMinutes()) this way, if the business logic required (in the future) to add meetings for future reference (such as making a meeting schedule for the next day or week ..etc), it'll be easy to adjust without being a break change. 
Dictionary&lt;Slot, string&gt; should be Dictionary&lt;int, Slot&gt; the int will represent the TrackNumber, which will remove the need of TrackNumber. 
GetScheduledTalk takes List&lt;string&gt; and return List&lt;Track&gt;, doesn't make any sense to me! using string list in this situation will be a real pain. Even if is it an input that you get from another resource (such as CVS). if there is any serialization process in this part, I would suggest moving it to a handler class, and create a model for it, then change the string to that model. 


Finally, Naming Convention, you should keep your objects names clearer by naming each object to its rule. if the object is related to another object, then include the name of that object as well. 

Here is a proposal that might help you in your implementation. 

public enum ScheduleSessionName
{
    Python,
    Java,
    Blender
}

public class ScheduleSessionSlot
{
    public ScheduleSessionName SessionName { get; set; }

    public DateTime SessionTimeStart { get; set; }

    public DateTime SessionTimeEnd { get; set; }

    //you can use this method if you want to make SessionTimeEnd readonly property, so it will be automatically set with def
    public DateTime SetDefaultSessionTime(DateTime sessionTimeStart)
    {
        switch (SessionName)
        {
            case ScheduleSessionName.Python:
                return sessionTimeStart.AddMinutes(90);
            case ScheduleSessionName.Java:
                return sessionTimeStart.AddMinutes(75);
            case ScheduleSessionName.Blender:
                return sessionTimeStart.AddMinutes(120);
            default:
                return sessionTimeStart.AddMinutes(60);
        }

    }

}

public interface ISchedule : IEnumerable
{      
    int Count { get; }

    void Add(int trackNumber, ScheduleSessionSlot sessionSlot);

    void Remove(int trackNumber);

    void Clear();

    new IEnumerator GetEnumerator();

}


public class Schedule : ISchedule
{

    private readonly Dictionary&lt;int, ScheduleSessionSlot&gt; _schedulesStore = new Dictionary&lt;int, ScheduleSessionSlot&gt;();

    public int Count =&gt; _schedulesStore.Count;

    public ICollection&lt;int&gt; TrackNumbers =&gt; _schedulesStore.Keys;

    public ICollection&lt;ScheduleSessionSlot&gt; SessionSlots =&gt; _schedulesStore.Values;

    public ScheduleSessionSlot this[int trackNumber]
    {
        get =&gt; _schedulesStore.ContainsKey(trackNumber) ? _schedulesStore[trackNumber] : null;
        set =&gt; _schedulesStore[trackNumber] = value;
    }


    public void Add(int trackNumber, ScheduleSessionSlot sessionSlot) =&gt; _schedulesStore.Add(trackNumber, sessionSlot);

    public void Remove(int trackNumber) =&gt; _schedulesStore.Remove(trackNumber);

    public bool Contains(int trackNumber) =&gt; _schedulesStore.ContainsKey(trackNumber);

    public bool Contains(ScheduleSessionSlot sessionSlot) =&gt; _schedulesStore.ContainsValue(sessionSlot);

    public bool Contains(KeyValuePair&lt;int, ScheduleSessionSlot&gt; schedule) =&gt; _schedulesStore.Contains(schedule);

    public void Clear() =&gt; _schedulesStore.Clear();

    public IEnumerator GetEnumerator() =&gt; _schedulesStore.GetEnumerator();

}


The rest, will require your action ;).