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

E>Ну а с другой стороны 15 функций с одним и тем же параметром тоже не здорово....
имхо, тут проблема не в том, как это выглядит, а в том насколько понятна мысль при взгляде на ту или иную функцию. По-моему, если есть две функции, в одной из которых создаётся экземпляр уровня класса, а в другой он используется, то уже есть над чем подумать, поскольку правильность работы начинает обусловливаться порядком вызова этих функций. И нарушить этот порядок слишком просто.
Если напрягают параметры в функциях, то это уже другой вопрос.
Решать можно так:

        static void Main(string[] args) {
            using (Some1Worker wkr = new Some1Worker()) {
                wkr.Func_01();
                wkr.Func_02();
                wkr.Func_15();
            }
        }

        private class Some1Worker : IDisposable {
            private Some1 _some;

            public Some1Worker() {
                _some = new Some1();
            }

            #region IDisposable Members

            public void Dispose() {
                _some.Dispose();
            }

            #endregion

            public void Func_01() {

            }
            public void Func_02() {

            }
            public void Func_15() {

            }
        }

        private class Some1 : IDisposable {

            #region IDisposable Members

            public void Dispose() {
                throw new NotImplementedException();
            }

            #endregion
        }

или так:

        static void Main(string[] args) {
            using (Some1 obj = new Some1()) {
                Some1Worker.DoSmthg(obj);
            }
        }

        private class Some1Worker {
            private Some1 _some;

            public static void DoSmthg(Some1 some) {
                new Some1Worker(some);
            }

            private Some1Worker(Some1 some) {
                _some = some;
                Func_01();
                Func_02();
                Func_15();
            }

            private void Func_01() {

            }
            private void Func_02() {

            }
            private void Func_15() {

            }
        }

        private class Some1 : IDisposable {

            #region IDisposable Members

            public void Dispose() {
                throw new NotImplementedException();
            }

            #endregion
        }

когда функции используют только то, что создаётся в конструкторе, не знаю — мне как-то спокойнее.

private void func1(Some some)
{
...
  some.GetRRRRR();
  some.SetRRRRR();
...
}

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


E>

E>public Some some;

E>public void Func()
E>{
E>...
E>using(some = new Some())
E>{
E>...
E>

сделайте переменную some локальной и передавайте ее статическим (если им не нужны другие члены) функциям. Еще можно реализовать IDisposable самим классом где определены все func

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

E>Что-то мне подсказывает, что дизайн корявенький... Как лучше делать?

Он везде такой посмотрите на TransactionScope например. Именно подобный подход там и предлагается...

public Some some;

public void Func()
{
...
using(some = new Some())
{
...
  func1();
  func2();
  func3();
  func4();
...
}
...
}
private void func1()
{
...
  some.GetRRRRR();
  some.SetRRRRR();
...
}
// Остальные функции:
//  func2();
//  func3();
//  func4();
// также как-то используют some...

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

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

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

E>>Что-то мне подсказывает, что дизайн корявенький... Как лучше делать?

TK>Он везде такой посмотрите на TransactionScope например. Именно подобный подход там и предлагается...
там такой подход предлагается для решения конкретной задачи — т.е. там в этом состоит сакральный смысл. тем более работа, насколько мне помнится ведётся не с полем, а со свойством — в свойство по крайней мере можно засунуть более ясное выражение ошибки, при отсутствии экземпляра.
а в общем случае, имхо, дизайн действительно кривоватенький — надеяться в функциях на то, что экземпляр будет создан, вместо того чтобы просто передать как параметр, мне кажется неправильным.

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

N>там такой подход предлагается для решения конкретной задачи — т.е. там в этом состоит сакральный смысл. тем более работа, насколько мне помнится ведётся не с полем, а со свойством — в свойство по крайней мере можно засунуть более ясное выражение ошибки, при отсутствии экземпляра.
N>а в общем случае, имхо, дизайн действительно кривоватенький — надеяться в функциях на то, что экземпляр будет создан, вместо того чтобы просто передать как параметр, мне кажется неправильным.
Ну а с другой стороны 15 функций с одним и тем же параметром тоже не здорово....

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

E>Ну а с другой стороны 15 функций с одним и тем же параметром тоже не здорово....

пропробуйте всетаки тогда реализовать в нем IDisposable. все станет намного логичнее.

private readonly Some some;

ctor()
{
  some = new Some();
}

Dipose()
{
  some.Dispose();
}

если эти func's далеко не единственные займитесь его декомпозицией

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

E>>Что-то мне подсказывает, что дизайн корявенький... Как лучше делать?

TK>Он везде такой посмотрите на TransactionScope например. Именно подобный подход там и предлагается...

Нет, "подобного" подхода:

using(Transaction.Current = new CommittableTransaction()) {
  …
}//using

как раз я нигде не видел, а именно это похоже на то, что делает топикстартер.

Подход же с TransactionScope как раз другой, поскольку в месте вызова _явно_ никаких side-effect-ов (как изменение глобального состояния) нет (то, что они происходят в фоне, так и пусть). В качестве бенефита, например, подход со Scope может принести "вложенность", тогда как явное изменение поля потребует гораздо больше телодвижений для достижения результата.

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

_FR>Нет, "подобного" подхода:
_FR>

_FR>using(Transaction.Current = new CommittableTransaction()) {
_FR>  …
_FR>}//using
_FR>

_FR>как раз я нигде не видел, а именно это похоже на то, что делает топикстартер.

Да, то что он some отдельно "прикопал" это плохо. Как-то я этого даже не заметил :xz:

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

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

_FR>>Нет, "подобного" подхода:
_FR>>

_FR>>using(Transaction.Current = new CommittableTransaction()) {
_FR>>  …
_FR>>}//using
_FR>>

_FR>>как раз я нигде не видел, а именно это похоже на то, что делает топикстартер.

TK>Да, то что он some отдельно "прикопал" это плохо. Как-то я этого даже не заметил
Вы знаете я и сам не заметил Имел ввиду именно private Some some;... т.е. не имел ввиду. а у меня проблема именно такая...