我的小应用程序出现严重问题；基本上很容易理解：

我的软件，当打开时，做它的事情。

我想专注于打开另一个实例（我的意思是再次打开 .exe），检查它是否已经打开。如果不是简单地启动应用程序，而是它已经在运行（也称为第二个或更多实例）“简单地”传递输入参数（args 字符串数组）传递给第一个实例，那么它将适当地处理它。

这是我的程序.cs

static class Program
{
    static Mutex mutex = new Mutex(true, "{blabla}");

    [STAThread]
    static void Main(String[] args)
    {
        if (mutex.WaitOne(TimeSpan.Zero, true))
        {
            //First Instance!

            try
            {
                Application.EnableVisualStyles();
                Application.SetCompatibleTextRenderingDefault(false);

                CALL A MY STATIC METHOD, DO SOME THINGS

                Application.Run(new Form1());
            }
            finally
            {
                mutex.ReleaseMutex();
            }
        }
        else
        {
            //Not-so-first instance!
            CALL A STATIC METHOD, 
            DO OTHER THINGS LIKE COMUNICATE WITH FIRST INSTANCE

            SIMPLY CLOSE.
        }
    }
}

这只会（使用互斥锁）识别它是否已经打开，但（当然）它无法与主实例进行任何通信。

我已经尝试了很多东西，但我无法让它工作。

我试过这个但我真的不明白（在浪费了很多时间之后）如何放置我的“第一次”代码和“已经运行”的代码。

也试过MSMQ但我不能让它工作。 …

我有 cloudformation 模板，其中包含两个具有 userdata 属性的实例。

我需要从一个实例的用户数据中获取数据并将其传递给另一个实例的用户数据。

例如（如下），需要从实例1获取“test”，并传递给实例2用户数据。

示例模板：

"instance1": {
  "Type": "AWS::EC2::Instance",
  "Properties": {
"UserData": {
      "Fn::Base64": {
        "Fn::Join": [
          "",
          [
            "#!/bin/bash\n",
            "set -x\n",
            "echo test\n",
          ]]}}}},

"instance2": {
  "Type": "AWS::EC2::Instance",
  "Properties": {
"UserData": {
      "Fn::Base64": {
        "Fn::Join": [
          "",
          [
            "#!/bin/bash\n",
            "set -x\n",
            //fetch the value
          ]]}}}},

我试图通过调用创建类的主程序之外的方法来删除类的实例。我通过搜索发现，为了进行垃圾收集，实例必须没有引用者。del在主程序中使用语句可以做到这一点，但我还需要通过方法删除实例，否则实例将很快堆积起来。我的代码是这样的：

class Agent_type:
def __init__(self, type_name, properties):
    self.type_name = type_name
    self.properties = properties
    self.agent_set = set()


class Agent:

    def __init__(self, agent_type):
        self.properties = agent_type.properties
        self.agent_type = agent_type
        agent_type.agent_set.update([self])

    def kill(self):
        self.agent_type.agent_set.remove(self)
        del self


def kill(agent):
    agent.agent_type.agent_set.remove(agent)
    del agent

programmer = Agent_type('programmer', {'language' : 'python'})
agent_1 = Agent(programmer)
print(agent_1)
print(programmer.agent_set)
agent_1.die()
# kill(agent_1)
print(programmer.agent_set)
print(agent_1)
del(agent_1)
print(programmer.agent_set)
try:
    print(agent_1)
except:
    print("agent deleted")

我得到的输出是：

<__main__.Agent object at 0x01A59290>
{<__main__.Agent object at 0x01A59290>}
set()
<__main__.Agent object at 0x01A59290>
set()
agent deleted …

我正在使用express 和sequelize 来创建REST API。我想只保留数据库的一个实例，并在我可能创建的所有路由中使用它。我的第一个想法是应用程序运行后立即创建实例。像这样的东西。

const express = require('express')
const databaseService = require( './services/database')
const config = require( './config')

const userRoute = require( './routes/user')

const app = express()

databaseService.connect(config.db_options).then(
    connectionInstance => {
        app.use('user', userRoute(connectionInstance))
        app.listen(3000)
    }
)

我还没有见过这样的事情，所以我相信这不是一个好方法。

有任何想法吗 ？

我的问题似乎与这个密切相关 。

我的代码解析 yaml 文件，重新排列对象并写入一个新的 yaml 文件。它工作得很好，但有一个特别难看的部分。

我必须将我的数据结构声明为 的实例，FromJson如下ToJson所示：

instance FromJSON Users where
  parseJSON = genericParseJSON (defaultOptions { fieldLabelModifier = body_noprefix })
instance ToJSON Users where
  toJSON = genericToJSON (defaultOptions { fieldLabelModifier = body_noprefix })

问题是我必须对 8 个左右的其他情况重复此操作：

instance FromJSON Role where
  parseJSON = genericParseJSON (defaultOptions { fieldLabelModifier = body_noprefix })
instance ToJSON Role where
  toJSON = genericToJSON (defaultOptions { fieldLabelModifier = body_noprefix })

...
...

我不知道如何避免这种重复。是否有某种方法可以仅声明两个函数一次（例如在新类中）并让所有这些数据类型从中派生？

解决方案（另请参阅 dfeuer 接受的答案）：

我个人喜欢这个解决方案。你需要添加

{-# language DerivingVia …

我在这里引用这个重复的问题：
Check if a Class Object is subclass of another Class Object in Java

我有一个名为“Figure”的抽象父类，其中有两个子类“Circle”和“Rectangle”，它们都扩展了这个抽象父类。我试图确定Figure 对象的类型是圆形还是矩形。

我原来的代码是：

 public boolean isInstanceOfRectangle(Figure figure)
 {
     boolean isInstance = figure instanceof Rectangle;
     System.out.println("instance of rectangle!");

     return isInstance;
  }

研究完上面链接的问题后，我重写了我的代码，如下所示：

public boolean isRectangle()
{
    boolean isInstance = Figure.class.isAssignableFrom(Rectangle); 
    System.out.println("instance of rectangle!");
    return isInstance;  
 }

由于某种原因，除非我在主类中包含以下内容，否则这不起作用：

public Class<?> Rectangle;
public Class<?> Circle1;

我不确定将其包含在我的类中的重要性，如果我不这样做，似乎需要我将它作为参数包含在我的方法中。我无法正确调用和测试此方法，因为我不确定调用时要传递到该方法中的参数。我想写一些类似的东西：

public void mouseReleased(MouseEvent e)
{
    if ((isRectangle(shape1)))
    addRectangle((Rectangle)shape1, e.getComponent().getForeground());

    else if ((isCircle(shape1)))
    addCircle((Circle) shape1, e.getComponent().getForeground());   
 }

其中“shape1”是实例化为圆形或矩形的Figure 对象。因为参数的类型为Figure，所以我不确定如何定义“isRectangle”方法来获取Figure 对象（抽象父级）并具体确定它是哪个子类的实例。或者最好不带任何参数，仅通过使用 Figure 对象调用该方法来完成工作。我有点困惑如何继续。

*编辑：根据用户的建议，我重写了以下内容，但它似乎不起作用，因为在这两种情况下输出都是 …

代码

考虑以下代码，一个基类，两个子类，以及一个采用一个子类的一个实例的函数。

abstract class AbstractNumberHolder {
    constructor(private readonly value: number) { }
    getValue() { return this.value; }
}

class UserId extends AbstractNumberHolder {
    equals(u: UserId) { return this.getValue() === u.getValue(); }
}

class SubscriptionCost extends AbstractNumberHolder {
    equals(s: SubscriptionCost) { return this.getValue() === s.getValue(); }
}

// ~~~

function printUserId(u: UserId) {
    console.log(u.getValue());
}

// ~~~

const subCost = new SubscriptionCost(50);
const uid = new UserId(1000105);

printUserId(subCost); // DOES NOT ERROR, WHILE IT SHOULD!

（上述代码的 Typescript Playground 链接） …

此代码来自 PyTorch 转换器：

    self.linear1 = Linear(d_model, dim_feedforward, **factory_kwargs)
    self.dropout = Dropout(dropout)
    self.linear2 = Linear(dim_feedforward, d_model, **factory_kwargs)
    self.norm1 = LayerNorm(d_model, eps=layer_norm_eps, **factory_kwargs)
    self.norm2 = LayerNorm(d_model, eps=layer_norm_eps, **factory_kwargs)
    self.norm3 = LayerNorm(d_model, eps=layer_norm_eps, **factory_kwargs)
    self.dropout1 = Dropout(dropout)
    self.dropout2 = Dropout(dropout)
    self.dropout3 = Dropout(dropout)

为什么他们要添加self.dropout1, ...2,...3当self.dropout已经存在并且是完全相同的功能时？

self.linear1另外，( , self.linear2) 和 之间有什么区别self.linear？

我正在学习课程，但不明白这一点：

class MyClass:
    var = 1

one = MyClass()
two = MyClass()

print(one.var, two.var) # out: 1 1
one.var = 2

print(one.var, two.var) # out: 2 1

我认为类变量可以被所有实例访问，为什么类变量不更新其所有实例？

我听说每个拉链都是一个共元，而我认为每个与其自身组成的拉链仍然是一个拉链，因此它是一个共元。所以我决定创建一个。

我有以下拉链列表：

{-# LANGUAGE DeriveFunctor #-}\n{-# LANGUAGE InstanceSigs #-}\nmodule ListZipper where\nimport Control.Comonad\nimport Data.List (unfoldr)\nimport Test.QuickCheck (Arbitrary (arbitrary))\n\ndata ListZipper a = ZList {previous :: [a], currentL :: a, next :: [a]} deriving (Functor, Eq)\n\ngoLeft, goRight :: ListZipper a -> Maybe (ListZipper a)\ngoLeft  (ZList (p:ps) cur ns) = Just $ ZList ps p (cur : ns)\ngoLeft _  = Nothing\ngoRight (ZList ps cur (n:ns)) = Just $ ZList (cur : ps) n ns\ngoRight _ = Nothing\n\nfork :: b -> (b, b)\nfork …