object или частьtypeне является частью метода. (Исключение составляют захваченные переменные, конечно.)

Если вы хотите получить эквивалент локальной статической переменной, создайте переменную экземпляра или статическую переменную - и подумайте, должен ли сам метод быть частью другого типа с этим состоянием.

еменных, выходящих за рамки класса или локального метода. Переменные внутри метода также не могут быть объявлены статическими, как вы привыкли делать в C. Однако вы всегда можете использовать статическую переменную класса в качестве замены.

Как правило, есть способы решения проблем программирования на C # без использования статики на уровне методов. Состояние - это обычно то, что вы должны проектировать в классы и типы, а не в методы.

что идея локальной статики так же легко решается путем создания открытых статических полей для класса. Как вы думаете, очень мало логических изменений?

Если вы думаете, что это будет большое логическое изменение, мне было бы интересно узнать, как это сделать.

class MyClass
{
    public static float MaxDepthInches = 3;

    private void PickNose()
    {
        if (CurrentFingerDepth < MyClass.MaxDepthInches)
        {
            CurrentFingerDepth++;
        }
    }
}

и метод является общим для всех экземпляров.

Мне пришлось исправить себя и других программистов, которые ожидают, что он будет уникальным для каждого экземпляра класса, используя метод.

Однако если вы сделаете его статическим классом или статическим экземпляром класса, синтаксически станет ясно, существует ли экземпляр для контейнера-класса или один экземпляр вообще.

Если вы ими не пользуетесь, то и рефакторинг станет легче позже.

как C #, но я полагаю, что вы можете достичь всего, что могли, с помощью локальной статики, используя статический уровень класса, который используется только для одного метода. Очевидно, что это связано с некоторыми синтаксическими изменениями, но я верю, что вы можете получить любую функциональность, которая вам нужна.

Кроме того, Эрик Липперт отвечает на такие вопросы на своемблог много. Вообще ответил всюда: "Меня спрашивают", почему "C # не реализует функцию X?" все время. Ответ всегда один и тот же: потому что никто никогда не проектировал, не определял, не реализовывал, не тестировал, не документировал и не поставлял эту функцию. & Quot; По сути, его ответы, как правило, сводятся к тому, что добавить какую-либо функцию стоит денег, и, следовательно, многие потенциальные функции не реализованы, поскольку они не проявили положительной стороны анализа затрат и выгод.

да. Это было бы то же самое, что статический член уровня класса, который использовался только в этом одном методе. Однако статический член уровня метода будет более инкапсулированным. Если данные, хранящиеся в элементе, предназначены для использования только одним методом, они должны быть доступны только этому единственному методу.

Тем не менее, вы можете достичь почти такого же эффекта в C #, создав вложенный класс.

Почему C # не поддерживает статические переменные метода? имеет дело с точным вопросом, заданным в оригинальном сообщении:

There are two reasons C# doesn't have this feature.

First, it is possible to get nearly the same effect by having a class-level static, and adding method statics would require increased complexity.

Second, method level statics are somewhat notorious for causing problems when code is called repeatedly or from multiple threads, and since the definitions are in the methods, it's harder to find the definitions.

[Author: Eric Gunnerson]

того. Поскольку C # ограничивает область действия статических переменных классами, вы можете использовать nested-class в качестве области действия.

Например:

public class Foo {
    public int Increment() {
        return IncrementInternal.Increment();
    }

    private static class IncrementInternal {
        private static int counter = 0;
        public static int Increment() {
            return counter++;
        }
    }
}

ВотFoo опорыIncrement метод, но его поддержка частным вложенным классомIncrementInternal который содержит статическую переменную в качестве члена. И, конечно же,counter не виден в контексте (другие методы)Foo.

Кстати, если вы хотите получить доступ кFoo контекст (другие члены и методы) внутриIncrementInternal.Increment, вы можете пройтиthis в качестве параметра дляIncrementInternal.Increment когда вы звоните изFoo.

Чтобы поддерживать область видимости как можно меньше, я предлагаю создать вложенный класс для каждого такого метода. И поскольку это, вероятно, не так часто, число вложенных классов останется достаточно маленьким, чтобы поддерживать его.

Я думаю, что это чище, чем анонимные функции или IIFE.

Вы можете увидеть живую демонстрациюВот.

чтобы удовлетворить себя.

Все аргументы о том, как вы должны кодировать, и что умного, и вам следует пересмотреть свой образ жизни, являются напыщенными защитными оправданиями.

Несомненно, C # является чистым и whatchamacallit-ориентированным. Вот почему они автоматически генерируют постоянные локальные значения для лямбда-функций. Все так сложно. Я чувствую себя так глупо

Статическая петля полезна и важна во многих случаях.

Короткий, реальный ответ: вы должны переместить локальную статику в область действия класса и жить с загрязнением пространства имен класса в C #. Подайте жалобу в мэрию.

ворт, объявляющуюХОРОШИЕ НОВОСТИ ВСЕМ!C # 6.0 позволяетusing static заявление. Это позволяет эффективно импортировать методы статического класса (а также свойства и члены) в глобальную область видимости.

Короче говоря, вы можете сделать что-то вроде этого:

using NUnit.Framework;
using static Fizz.Buzz;

class Program
{
    [Test]
    public void Main()
    {
        Method();
        int z = Z;
        object y = Y;
        Y = new object();
    }
}


namespace Fizz
{
    class Buzz
    {
        public static void Method()
        {
        }

        public static int Z;

        public static object Y { get; set; }
    }
}   

Хотя это доступно только в C # 6.0, насколько я понимаю, сгенерированные сборки должны быть совместимы с предыдущими платформами .NET (поправьте меня, если я ошибаюсь).

вы хотите использовать статическую локальную переменную в своем методе? Поздравляем! Вы сделали еще один шаг к тому, чтобы статьreal программист.

Не слушайте всех людей, говорящих вам, что статические локальные объекты не являются «чистыми», что они препятствуют «читабельности» и может привести к неуловимым и труднодоступным «ошибкам». Ерунда! Они просто говорят это, потому что ониwannabe программисты! Многие из них, вероятно, даже играют с эзотерическим функциональным языком программирования в свободное время. Ты можешь в это поверить? Какая куча хипстеров!

Real программисты принимают парадигму, которую я люблю называтьSDD - Side effect Driven Design, Вот некоторые из наиболее важных законов:

Don't be predictable! Never return the same thing from a method twice - even if it's being called with the exact same arguments!

Screw purity - let's get dirty! State, by nature, craves changing, because it is an insatiable monoid in the category of polyamorous endofunctors, i.e. it likes to be touched by as many collaborators as possible. Never miss out on an opportunity to do it the favor!

Среди инструментов, используемых для кодирования побочным эффектом, есть, конечно же, статические локальные переменные. Однако, как вы заметили, C # не поддерживает их. Зачем? Потому что за последние два десятилетияMicrosoft has been infiltrated by so called Clean Coders что поддерживает ремонтопригодность, а не гибкость и контроль. Можете ли вы вспомнить, когда в последний раз видели наш любимый синий экран? Теперь угадайте, чья это вина!

Но не бойся!Real разработчики не должны страдать от этих плохих дизайнерских решений. Как уже упоминалось ранее, с помощью лямбды можно иметь локальные переменные, которые являются своего рода статическими.

Однако предоставленное решение не было вполне удовлетворительным. С использованиемпредыдущий ответ наш почти SDD-совместимый код будет выглядеть примерно так:

var inc = Increment();
var zero = inc();
var one = inc();

или же

var zero = Increment()();

Но это просто глупо. Дажеwannabe разработчик может видеть, чтоIncrement() это не нормальный метод и станет подозрительным.real программист, с другой стороны, может сделать его еще более SDD-подобным. Он или она знает, что мы можем сделать свойство или поле похожим на метод, задав ему типFunc<T>! Нам просто нужно инициализировать его, выполнив лямбду, которая, в свою очередь, инициализирует счетчик и возвращает другую лямбда, увеличивающую захваченный счетчик!

Вот это в правильном SDD-коде:

public Func<int> Increment = new Func<Func<int>>(() =>
{
    var num = 0;
    return () => num++;
}).Invoke();

(Вы думаете, что вышеупомянутый вид выглядит какIIFE? Да, вы правы и вам должно быть стыдно за себя.)

Теперь каждый раз, когда вы звонитеIncrement() это вернет что-то другое:

var zero = Increment();
var one = Increment();

Конечно, вы также можете сделать так, чтобысчетчик выживает на протяжении всей жизни вашего экземпляра.

Это покажет имwannabe программисты!