标签: class-variables

我正在使用C#使用Active Directory.实例化PrincipalContext对象似乎很昂贵,所以我想将一个存储在一个类变量中.

当PrincipalContext用作局部变量时,我可以使用方便的using语法.将IDisposable对象存储在静态变量中时,如何确保对象被正确处理？

订单之间有什么区别:

public static final String = "something";

要么

public final static String = "something";

？

这可能是一个简单的问题,但我无法进行独特的搜索.

我有一个定义静态字典的类,然后尝试静态地定义该字典的子集.

所以,作为玩具的例子:

class example(object): 
    first_d = {1:1,2:2,3:3,4:4} 
    second_d = dict((k,first_d[k]) for k in (2,3))

这产生了 NameError: global name 'first_d' is not defined

我该怎么做这个参考？似乎这种模式适用于其他情况,例如:

class example2(object):
    first = 1
    second = first + 1

我在课堂上有一个部分,我决定分成一个新部分.

当我将代码段移植到一个新类时,我注意到它在执行一个foreach循环时要慢得多.

我设法找出问题的一部分,以便我决定保存最终结果数组.

我认为如果你看到我的代码的缩短版本会更容易理解:

原始移植代码:http://pastebin.com/2iBuqmgn 更优化的移植代码:http://pastebin.com/TYU1rHwU

你会看到,在第一个例子中,我直接操纵$ this-> active_topics.

在第二个例子中,我使用局部变量,然后在foreach循环之后将局部变量保存到$ this-> active_topics.

原始循环似乎平均为1秒,而更优化的循环使用0.85平均执行.他们最终返回完全相同的内容.

为什么使用局部变量更优化的代码更有效？

假设使用类变量的简单ruby程序,

    class Holder
      @@var = 99
      def Holder.var=(val)
        @@var = val
      end
      def var
        @@var
      end
    end

    @@var = "top level variable"

    a = Holder.new
    puts a.var

我想结果应该是99,但输出不是99.我想知道为什么.由于类变量的范围是类,我假设该行@@var = "top level variable"不会影响类中的变量.

在模块a.py中

def task(): 
    print "task called"

a = task

class A:

    func = task              # this show error unbound method
    #func = task.__call__    # if i replace with this work

    def __init__(self):
        self.func_1 = task

    def test_1(self):
        self.func_1()

    @classmethod
    def test(cls):
        cls.func()


a()
A().test_1()
A.test()

输出:

task called
task called
Traceback (most recent call last):
  File "a.py", line 26, in <module>
     A.test()
  File "a.py", line 21, in test
     cls.func()
TypeError: unbound method task() must be called with A instance …

我理解(我认为)Ruby中类的类变量和实例变量之间的区别.

我想知道如何从OUTSIDE那个类访问类的实例变量.

从内部(即在类方法而不是实例方法中),它可以直接访问,但是从外部,有没有办法MyClass.class.[@$#]variablename呢？

我没有任何具体的理由这样做,只是学习Ruby并想知道它是否可行.

我有一些常量只需要在编译时使用来简化代码,所以我不需要在运行时可用的实际变量.

传统上这样做的方式是,#define NAME 123但我想要一个类型安全的替代品.

在课程之外你可以const int name = 123;正常工作,但似乎不可能把它放在一个类中.例如:

class Example {
    public:
        const double usPerSec = 1000000.0;
};
double usOneMinute = 60 * Tempo::usPerSec;

使用Visual C++,但不适用于GCC:

error: non-static const member ‘const double Example::usPerSec’,
  can’t use default assignment operator

您可以通过使其静态来修复它,但随后Visual C++抱怨:

error C2864: 'Example::usPerSec' : a static data member with an in-class
  initializer must have non-volatile const integral type
    type is 'const double'

我猜这意味着VC++只会接受static const int.

我想避免在构造函数中设置值,因为我在运行时需要一个类的实例来访问该值,而实际上我希望它在编译时像处理它一样处理#define.

那么如何将一个常量定义为double类的内部,而不是使其成为全局或使用#define,这将在没有类的实例的情况下工作,并且将与主要的C++ …

我读到在类命名空间中创建变量然后在类构造函数中更改其值被认为是不好的做法。

（我的一个来源：SoftwareEngineering SE：在 Python 的类中将实例变量声明为 None 是一种好习惯。）

考虑以下代码：

# lib.py
class mixin:
    def __init_subclass__(cls, **kwargs):
        cls.check_mixin_subclass_validity(cls)
        super().__init_subclass__(**kwargs)

    def check_mixin_subclass_validity(subclass):
        assert hasattr(subclass, 'necessary_var'), \
            'Missing necessary_var'

    def method_used_by_subclass(self):
        return self.necessary_var * 3.14


# app.py
class my_subclass(mixin):
    necessary_var = None

    def __init__(self, some_value):
        self.necessary_var = some_value

    def run(self):
        # DO SOME STUFF
        self.necessary_var = self.method_used_by_subclass()
        # DO OTHER STUFF

为了强制其子类声明变量required_var，该类mixin使用元类subclass_validator。

我所知道的让它同时工作的唯一方法app.py是将必要的变量初始化为类变量。

我错过了什么还是这是唯一的方法？

我在 FastAPI 应用程序中有以下类：

import asyncio
import logging
from multiprocessing import Lock, Process

from .production_status import Job as ProductionStatusJob


class JobScheduler:
    loop = None
    logger = logging.getLogger("job_scheduler")
    process_lock = Lock()
    JOBS = [ProductionStatusJob]

    @classmethod
    def start(cls) -> None:
        cls.logger.info("Starting Up (1/2)")
        Process(target=cls._loop).start()
    
    @classmethod
    def _loop(cls) -> None:
        cls.loop = asyncio.get_event_loop()
        cls.loop.create_task(cls._run())
        cls.logger.info("Startup Complete (2/2)")
        cls.loop.run_forever()
        cls.loop.close()

    @classmethod
    async def _run(cls) -> None:
        while True:
            ...

    @classmethod
    async def stop(cls) -> None:
        cls.logger.info("Shutting Down (1/2)")
        with cls.process_lock:
            cls.loop.stop()                          # <= This Line …