Николай Богданов

public class Interval
{
    DateTime LeftBound { get; set; }
    DateTime RightBound { get; set; }

    public Interval(DateTime left, DateTime right)
    {
       LeftBound = left;
       RightBound = right;
    }
}

...

List<Interval> intervals = new List<Interval>
{
    new Interval(DateTime.Parse("12:00:00"), DateTime.Parse("13:00:00")),
    new Interval(DateTime.Parse("14:00:00"), DateTime.Parse("20:00:00"))
};

...

public Color CheckInterval(DateTime now, List<Interval> timeTable)
{
   Color color = Color.Green;

   foreach (Interval interval in timeTable)
   {
      if (now > interval.LeftBound && now < interval.RightBound) 
      {
         color = Color.Red;
         break;
      }
   }

   return color;
}

...

label1.ForeColor = CheckInterval(DateTime.Now, intervals);

using System;  
using System.Text;  

namespace OverrideAndNew  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            BaseClass bc = new BaseClass();  
            DerivedClass dc = new DerivedClass();  
            BaseClass bcdc = new DerivedClass();  

            // The following two calls do what you would expect. They call  
            // the methods that are defined in BaseClass.  
            bc.Method1();  
            bc.Method2();  
            // Output:  
            // Base - Method1  
            // Base - Method2  

            // The following two calls do what you would expect. They call  
            // the methods that are defined in DerivedClass.  
            dc.Method1();  
            dc.Method2();  
            // Output:  
            // Derived - Method1  
            // Derived - Method2  

            // The following two calls produce different results, depending   
            // on whether override (Method1) or new (Method2) is used.  
            bcdc.Method1();  
            bcdc.Method2();  
            // Output:  
            // Derived - Method1  
            // Base - Method2  
        }  
    }  

    class BaseClass  
    {  
        public virtual void Method1()  
        {  
            Console.WriteLine("Base - Method1");  
        }  

        public virtual void Method2()  
        {  
            Console.WriteLine("Base - Method2");  
        }  
    }  

    class DerivedClass : BaseClass  
    {  
        public override void Method1()  
        {  
            Console.WriteLine("Derived - Method1");  
        }  

        public new void Method2()  
        {  
            Console.WriteLine("Derived - Method2");  
        }  
    }  
}

Контракты на интерфейсах
и абстрактных методах

Мощной возможностью контрактов кода является добавление условий к членам интерфейса и абстрактным методам. Двоичное средство перезаписи автоматически привязывает эти условия к конкретным реализациям членов. Специальный механизм позволяет указывать отдельный класс контракта для интерфейсов и абстрактных методов, поэтому можно написать тела методов для хранения условий контрактов. Ниже показано, как это работает:

[ContractClass (typeof (ContractForITest))] 
interface ITest 
{ 
    int Process (string s); 
}

[ContractClassFor (typeof (ITest))] 
sealed class ContractForITest : ITest 
{  
    int ITest.Process (string s) // должна использоваться явная реализация. 
    { 
        Contract.Requires (s != null); 
        return 0; // Фиктивное значение, чтобы удовлетворить компилятор. 
    } 
}

Обратите внимание, что для удовлетворения компилятора мы должны вернуть значение при реализации метода ITest.Process. Однако код, возвращающий 0, выполняться не будет. Вместо этого двоичное средство перезаписи извлекает из метода только условия и связывает их с реальными реализациями ITest.Process. Это значит, что экземпляры класса контракта никогда в действительности создаваться не будут (и любые конструкторы, которые вы напишете, также выполняться не будут). Внутри блока контракта можно реализовать присваивание временной переменной, чтобы проще было ссылаться на другие методы интерфейса. Например, если в интерфейсе ITest также определено свойство Message типа string, в ITest.Process можно было бы написать следующий код:

int ITest.Process (string s) 
{ 
    ITest test = this;
    Contract.Requires (s != test.Message);
    ...
}

Это проще, чем:

(Простое использование this Message работать не будет, т.к. свойство Message должно быть реализовано явно.) Процесс определения классов контрактов для абстрактных классов выглядит точно так же за исключением того, что класс контракта должен быть помечен как abstract вместо sealed.

Неоходим анализ опций компилятора в обоих случаях. Можете показать?