Ну и еще один этюд.
Приведите пример, как unreachable код может влиять на результат программы. Рефлексия не считается.
С кем обсуждали это в личной переписке — пожалуйста, не торопитесь писать ответ здесь.

Что значит "влиять"? Когда программа должна менять результат? При удалении недостижимого кода?

Здравствуйте, Pro100Oleh, Вы писали:

PO>Когда программа должна менять результат? При удалении недостижимого кода?

Да.

Такое считается?

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Main");
            string s = "1";
            if (s == "1") return;
            A.Do();
        }
    }

    public static class A
    {
        public static readonly Hi h = new Hi();

        //static A()
        //{

        //}

        public static void Do()
        {
        }
    }

    public class Hi
    {
        public Hi()
        {
            Console.WriteLine("Hi");
        }
    }
}

Вроде при таком коде тоже можен работать, но поведение будет "недетерминированно":

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Main");
            return;
            A.Do();
        }
    }
   
   ...

Здравствуйте, Pro100Oleh, Вы писали:

PO>Такое считается?

PO>

PO>            string s = "1";
PO>            if (s == "1") return;
PO>            A.Do();

Нет, такой код не считается unreachable.

PO>Вроде при таком коде тоже можен работать, но поведение будет "недетерминированно":

PO>

PO>            return;
PO>            A.Do();

Ну, у меня не работает.

N>Нет, такой код не считается unreachable.
а какой считается?

зы. опять 3.0 или ранний дотнет можно?

Здравствуйте, Ovl, Вы писали:

N>>Нет, такой код не считается unreachable.
Ovl>а какой считается?

8.1 End points and reachability
If a statement can possibly be reached by execution, the statement is said to be reachable. Conversely, if there is no possibility that a statement will be executed, the statement is said to be unreachable. <...>
To determine whether a particular statement or end point is reachable, the compiler performs flow analysis according to the reachability rules defined for each statement. The flow analysis takes into account the values of constant expressions (§7.18) that control the behavior of statements, but the possible values of non-constant expressions are not considered. In other words, for purposes of control flow analysis, a non-constant expression of a given type is considered to have any possible value of that type.

Ovl>зы. опять 3.0 или ранний дотнет можно?
Ну, опять же, я знаю решение, использующее особенности C# 3.0, но буду рад увидеть любые решения.

P.S. Кто не заметил, еще один интересный этюд лежит

Автор: nikov
Дата: 11.06.08

нерешенным в соседнем форуме.

читерство вроде

    public class Program
    {
        const int Test = 0;

        static void Main()
        {
            if (Test != 0)
                Console.WriteLine(9);
            Console.WriteLine(1);
        }
    }

не покатит?

Здравствуйте, Ovl, Вы писали:

Ovl>читерство
Ovl>не покатит?

Нет, надо честно, не меняя структуру блоков и условных операторов.

Убил на это 3 часа!

    class Program
    {
        static void Main(string[] args)
        {
            D(() =>
            {
                return 1;
                return 2.2;
            });
        }

        static void D(Func<int> f)
        {
            Console.WriteLine("int");
        }

        static void D(Func<double> f)
        {
            Console.WriteLine("double");
        }
    }

Здравствуйте, Pro100Oleh, Вы писали:

PO>

PO>            D(() =>
PO>            {
PO>                return 1;
PO>                return 2.2;
PO>            });
PO>

Да!

Здравствуйте, nikov, Вы писали:

N>Здравствуйте, Pro100Oleh, Вы писали:

PO>>

PO>>            D(() =>
PO>>            {
PO>>                return 1;
PO>>                return 2.2;
PO>>            });
PO>>

N>Да!
Я так понял злую шутку сыграл вывод типов лямбды?
Что стандарт по этому поводу говорит?

Здравствуйте, migel, Вы писали:

M>Я так понял злую шутку сыграл вывод типов лямбды?
Да.
M>Что стандарт по этому поводу говорит?
Стандарт говорит (7.4.2.6 Output type inferences), что при выводе типов из анонимной функции используется ее inferred return type. А этот тип (7.4.2.11 Inferred return type) в случае, если тело анонимной функции является блоком, вычисляется как best common type выражений во всех return statements в этом блоке. То есть точно так же, как если бы все эти выражения были элементами неявно типизированого массива.

Здравствуйте, Pro100Oleh, Вы писали:

PO>Убил на это 3 часа!

Можно еще вот так:

using System;

class A
{
    static void Main()
    {
        Foo(x =>
                {
                    return;
                    x = 1;
                }, "");
    }
    static void Foo(Action<string> x, string y)
    {
        Console.WriteLine(1);
    }
    static void Foo(Action<int> x, object y)
    {
        Console.WriteLine(0);
    }
}

Здравствуйте, nikov, Вы писали:

N>Стандарт говорит (7.4.2.6 Output type inferences), что при выводе типов из анонимной функции используется ее inferred return type. А этот тип (7.4.2.11 Inferred return type) в случае, если тело анонимной функции является блоком, вычисляется как best common type выражений во всех return statements в этом блоке. То есть точно так же, как если бы все эти выражения были элементами неявно типизированого массива.

Ой, я наврал. Это объяснение подходит для такого случая:

using System;

class Program
{
    static void Main()
    {
        D(() =>
        {
            return 1;
            return 2.2;
        });
    }

    static void D<T>(Func<T> f)
    {
        Console.WriteLine(typeof(T));
    }
}

А для исходного примера надо смотреть 6.6 Method group conversions и 7.4.3.3 Better conversion from expression.

PO>Убил на это 3 часа!
PO>

PO>    class Program
PO>    {
PO>        static void Main(string[] args)
PO>        {
PO>            D(() =>
PO>            {
PO>                return 1;
PO>                return 2.2;
PO>            });
PO>        }
PO>        static void D(Func<int> f)
PO>        {
PO>            Console.WriteLine("int");
PO>        }
PO>        static void D(Func<double> f)
PO>        {
PO>            Console.WriteLine("double");
PO>        }
PO>    }
PO>

Вот только считать ли это хорошей стороной C#...

Здравствуйте, Pavel_Agurov, Вы писали:

P_A>Вот только считать ли это хорошей стороной C#...

Ну, это еще что! Я вот так умею:

using System;

class Program
{
    static void Main()
    {
        Bar(x =>  (x).Foo (), ""); // 1
        Bar(x => ((x).Foo)(), ""); // 2
    }

    static void Bar(Action<C<int>> x, string y) { Console.WriteLine(1); }
    static void Bar(Action<C<Action>> x, object y) { Console.WriteLine(2); }
}

static class B
{
    public static void Foo(this object x) { }
}

class C<T>
{
    public T Foo;
}

Здравствуйте, nikov, Вы писали:

P_A>>Вот только считать ли это хорошей стороной C#...

И еще вот так:

using System;

class A
{
    static void Foo() { }
    class B
    {
        const int Foo = 1;
        static void Main()
        {
            // Foo();
            Bar(Foo);
        }

        static void Bar(Action f)
        {
            Console.WriteLine(1);
        }

        static void Bar(int f)
        {
            Console.WriteLine(2);
        }
    }
}

А теперь попробуйте раскомментировать строку Foo().

P_A>>>Вот только считать ли это хорошей стороной C#...
N>И еще вот так:
N>

N>    static void Foo() { }
N>        const int Foo = 1;
N>            Bar(Foo);
N>

N>А теперь попробуйте раскомментировать строку Foo().

Мастерство не пропьешь

А, если серьезно, то не хорошо это. В 2.0 такая шутка не прокатывает, а в 3 работает. Плохо даже не то что можно именно так, а что уходит строгость. Ну хоть warning можно было дать, что имена одинаковые? Мне кажется можно. Хочется мне именно так делать — ну выключу варнинг в этом месте. А то так скоро и к if (i=5) вернемся.
Впрочем это так... мысли вслух. Сейчас мне докажут что так и нужно и было задумано

Здравствуйте, Pavel_Agurov, Вы писали:

P_A>Вот только считать ли это хорошей стороной C#...

Скоро C# превратится в C++... Все возвращается на круги своя.