小编cgy*_*per的帖子

我已经看到一些插件和自定义rake任务将活动数据库转储到灯具,但我不确定主流技术是什么.

基本上,我想要与rake相反:db:fixtures:load,以便我可以在部署时将基本数据库信息(管理员用户帐户,一个)放入svn中.我不想手动创建夹具,例如需要很长时间的样本数据.

当我们部署时,我希望能够运行

rake db:migrate
rake db:fixtures:load

并参加比赛.

在rails中执行此操作的最佳/首选方法是什么？

编辑:

所以似乎没有标准的方法来执行db:fixtures:load的相反rake任务.

我不想使用迁移,因为我想要一个标准的方法来为我的所有项目执行此操作,并且我不喜欢在迁移中添加更多管理员帐户的想法.其次,我一直在重新思考使用灯具的想法.我决定使用yaml_db,因为它使用rake任务:

rake db:data:dump
rake db:data:load

数据将在YAML文件中结束而不会破坏测试装置(可能会有所不同,现在我更仔细地考虑这个问题).此外,如果像Heroku这样的主要发行工具正在使用它,我不必担心支持/长寿问题.

我想这最接近我会找到的"标准".

感谢所有的好评.

我有一个系统,远程代理发送序列化结构(来自嵌入式C系统)供我通过IP/UDP读取和存储.在某些情况下,我需要发回相同的结构类型.我以为我使用Marshal.PtrToStructure(接收)和Marshal.StructureToPtr(发送)进行了很好的设置.但是,一个小问题是网络大端整数需要转换为我的x86小端格式才能在本地使用.当我再次发送它们时,大端是可行的方式.

以下是有问题的功能:

    private static T BytesToStruct<T>(ref byte[] rawData) where T: struct
    {
        T result = default(T);
        GCHandle handle = GCHandle.Alloc(rawData, GCHandleType.Pinned);
        try
        {
            IntPtr rawDataPtr = handle.AddrOfPinnedObject();
            result = (T)Marshal.PtrToStructure(rawDataPtr, typeof(T));
        }
        finally
        {
            handle.Free();
        }
        return result;
    }

    private static byte[] StructToBytes<T>(T data) where T: struct
    {
        byte[] rawData = new byte[Marshal.SizeOf(data)];
        GCHandle handle = GCHandle.Alloc(rawData, GCHandleType.Pinned);
        try
        {
            IntPtr rawDataPtr = handle.AddrOfPinnedObject();
            Marshal.StructureToPtr(data, rawDataPtr, false);
        }
        finally
        {
            handle.Free();
        }
        return rawData;
    }

还有一个可以像这样使用的快速示例结构:

byte[] data = this.sock.Receive(ref …

我有一个应用程序使用TextBox将消息记录到屏幕上.更新功能使用一些Win32函数来确保框自动滚动到结尾,除非用户正在查看另一行.这是更新功能:

private bool logToScreen = true;

// Constants for extern calls to various scrollbar functions
private const int SB_HORZ = 0x0;
private const int SB_VERT = 0x1;
private const int WM_HSCROLL = 0x114;
private const int WM_VSCROLL = 0x115;
private const int SB_THUMBPOSITION = 4;
private const int SB_BOTTOM = 7;
private const int SB_OFFSET = 13;

[DllImport("user32.dll")]
static extern int SetScrollPos(IntPtr hWnd, int nBar, int nPos, bool bRedraw);
[DllImport("user32.dll", CharSet = CharSet.Auto)]
private static extern int GetScrollPos(IntPtr hWnd, int …

我需要为我的C#程序构建脚本接口,对嵌入式固件进行系统级测试.

我的应用程序包含与设备完全交互的库.有单独的库用于启动操作,获取输出和跟踪成功/失败.我的应用程序还有一个GUI,用于管理多个设备并分配许多要运行的脚本.

对于测试人员(非程序员,但技术人员),我需要提供一个脚本界面,使他们能够提出不同的测试和运行方案.他们只是调用我的API,然后将结果返回给我的程序(通过/失败和消息).

我想要的一个非常基本的例子:

TURN_POWER_ON
TUNE_FREQUENCY frequency
WAIT 5
IF GET_FREQUENCY == frequency
  REPORT_PASS "Successfully tuned to " + frequency
ELSE
  REPORT_FAIL "Failed to tune to " + frequency
ENDIF
TURN_POWER_OFF

报告,电源和频率功能由我的C#库提供.

像IronRuby或IronPython这样的东西会对此有好处,还是我应该建立自己的基本语言？

在尝试包含一堆.NET编译的程序集时,Ruby/Python代码是否会变得混乱？我希望它对于非程序员和程序员来说都很容易学习和编写代码.

编辑:

感谢所有的好评.我选择IronPython作为答案,因为它得到了最多的支持,但我会花一些时间与IronPython,Boo和IronRuby分别看看测试人员更愿意编写脚本.

感谢上一个问题的建议,我正忙着尝试使用IronPython,IronRuby和Boo为我的C#应用​​程序创建一个DSL.由于更大的用户和知识库,第一步是IronPython.如果我能在这里找到合适的东西,我可以停下来.

这是我的问题:

我希望我的IronPython脚本可以访问名为Lib的类中的函数.现在我可以将程序集添加到IronPython运行时并通过执行我创建的作用域中的语句来导入该类:

// load 'ScriptLib' assembly
Assembly libraryAssembly = Assembly.LoadFile(libraryPath);
_runtime.LoadAssembly(libraryAssembly);

// import 'Lib' class from 'ScriptLib'
ScriptSource imports = _engine.CreateScriptSourceFromString("from ScriptLib import Lib", SourceCodeKind.Statements);
imports.Execute(_scope);

// run .py script:
ScriptSource script = _engine.CreateScriptSourceFromFile(scriptPath);
script.Execute(_scope);

如果我想运行Lib :: PrintHello,这只是一个hello world style语句,我的Python脚本包含:

Lib.PrintHello()

或(如果它不是静态的):

library = new Lib()
library.PrintHello()

如何更改我的环境,以便我可以在Python脚本中获得如下的基本语句:

PrintHello
TurnOnPower
VerifyFrequency
TurnOffPower
etc...

我希望这些脚本对于非程序员来说很简单.我不希望他们必须知道课程是什么或它是如何工作的.IronPython真的就在那里,所以像for,do,if和基本函数定义这样的基本操作不需要我为我的DSL编写编译器.

我需要一些帮助来找到我遇到的内存泄漏的解决方案.我有一个C#应用程序(.NET v3.5),允许用户运行IronPython脚本进行测试.脚本可以加载Python标准库中的不同模块(包含在IronPython二进制文件中).但是,当脚本完成时,分配给导入模块的内存不会被垃圾回收.循环使用一个脚本的多次运行(完成压力测试)会导致系统在长期使用期间耗尽内存.

这是我正在做的简化版本.

脚本类主要功能:

public void Run()
{
    // set up iron python runtime engine
    this.engine = Python.CreateEngine(pyOpts);
    this.runtime = this.engine.Runtime;
    this.scope = this.engine.CreateScope();

    // compile from file
    PythonCompilerOptions pco = (PythonCompilerOptions)this.engine.GetCompilerOptions();
    pco.Module &= ~ModuleOptions.Optimized;
    this.script = this.engine.CreateScriptSourceFromFile(this.path).Compile(pco);

    // run script
    this.script.Execute(this.scope);

    // shutdown runtime (run atexit functions that exist)
    this.runtime.Shutdown();
}

加载随机模块的示例'test.py'脚本(添加~1500 KB的内存):

import random
print "Random number: %i" % random.randint(1,10)

一种循环机制,会导致系统内存不足:

while(1)
{
    Script s = new Script("test.py");
    s.Run();
    s.Dispose();
}

我添加了一节以不根据我在此线程中找到的内容优化编译,但内存泄漏发生在任何一种方式.将显式调用添加到s.Dispose()也没有任何区别(如预期的那样).我目前正在使用IronPython 2.0,但我也尝试过升级到IronPython 2.6 RC2而没有任何成功.

当脚本引擎/运行时超出范围时,如何将嵌入式IronPython脚本中导入的模块像普通.NET对象一样进行垃圾收集？

我需要编写一个委托函数,它可以围绕基本的UDP调用"包裹"一些/ try/catch代码来验证链接.我让Func为一个没有参数的函数工作,但我不能使它适用于Action,它有一个参数(但没有返回).在没有编译器抱怨的情况下,我似乎无法以逻辑方式传递参数.

我错了吗？我是C#的新手,我基本上试图模仿函数指针的想法.我不应该重载这个功能吗？我知道你不能重载代表(我认为这就是Func和Action存在的原因).

这有效:

protected TResult udpCommand<TResult>(Func<TResult> command)
        {
            TResult retValue = default(TResult);
            while (!linkDownFail)
            {
                try
                {
                    retValue = command();
                    break;
                }
                catch
                {
                    LinkStateCallBack(ip, getLinkStatus());
                    if (linkDownFail) throw new LinkDownException();
                    Thread.Sleep(100);
                }
            }
            return retValue;
        }

但这不是:

protected void udpCommand<T>(Action<T> command(T value))
        {
            while(!linkDownFail)
            {
                try
                {
                    command(value);
                    break;
                }
                catch
                {
                    LinkStateCallBack(ip, getLinkStatus());
                    if (linkDownFail) throw new LinkDownException();
                    Thread.Sleep(100);
                }
            }
            return;
        }

调用约定(适用于一个):

udpCommand<uint>(someUdpCommand);

我正在尝试在.NET库中使用ImageMagick COM对象(ImageMagickObject).这个库旨在从IronRuby中调用,但这并不是那么重要.我想采用这种方法,因为它适合我现有的调用,当前调用ImageMagick二进制文件作为外部进程.COM对象将采用与二进制文件相同的参数,但将保存进程创建速度,整体速度提高约5倍.

我唯一的障碍是COM对象的"Compare"方法将其结果返回给STDERR.这也是二进制文件的一个问题,但很容易将其传回STDOUT,我期待它.使用COM对象,我从函数返回值中获取结果.

如何将结果从"比较"重定向到字符串缓冲区甚至文件而不是STDERR？

我尝试了以下操作,它确实阻止输出到达STDERR,但它没有按预期写入文件:

using ImageMagickObject;
...

public class ImageMagickCOM
{
    [DllImport("Kernel32.dll", SetLastError = true)]
    public static extern int SetStdHandle(int device, IntPtr handle);

    private const int STDOUT_HANDLE = -11;
    private const int STDERR_HANDLE = -12;

    private ImageMagickObject.MagickImage magickImage = null;

    private FileStream filestream = null;
    private StreamWriter streamwriter = null;

    public ImageMagickCOM()
    {
        IntPtr handle;
        int status;

        filestream = new FileStream("output.txt", FileMode.Create);
        streamwriter = new StreamWriter(filestream);
        streamwriter.AutoFlush = true;

        //handle = filestream.Handle; // deprecated
        handle = filestream.SafeFileHandle.DangerousGetHandle(); // replaces …

我的C#应用​​程序中有一个嵌入式脚本引擎,它使用IronPython 2.我创建Python运行时并向全局命名空间添加一些类,以便脚本可以将它们作为模块导入.

但是,一个(非常基本的)我无法弄清楚的是如何发送脚本参数.我意识到我可以创建一个带有参数列表的变量,但必须有一个正确的方法来完成它.此外,以正确的"Python"方式执行此操作允许我编译脚本并使用名为Sphinx的自动文档构建器.所以最终的目标是能够使用:

import sys
sys.argv

在我的一个脚本中,让它获得用户指定的参数(通过C#app).

现在,我使用以下方法调用脚本:

// set up iron python runtime engine
_engine = Python.CreateEngine();
_runtime = _engine.Runtime;
_scope = _engine.CreateScope();

// run script
_script = _engine.CreateScriptSourceFromFile(_path);
_script.Execute(_scope);

我已经尝试搜索一个API来添加脚本参数而没有运气.我也尝试将它们附加到脚本路径(示例中为_path),但没有运气.我尝试使用CreateScriptSourceFrom File和CreateScriptSourceFromSting(无论如何都是一个很长的镜头......).

我正在努力做甚么可能吗？

我在我的 C# 应用程序中嵌入了 IronPython。出于某种原因，我在加载程序集时遇到了问题。具体来说，我想要 System.dll，这样我就可以访问 DateTime 等 .NET 类。

如果我尝试这一行：

_runtime.LoadAssembly(_runtime.Host.PlatformAdaptationLayer.LoadAssembly("System"));

我得到：

could not load file or assembly 'System'

如果我明确输入 C:/WINDOWS/Microsoft.NET/.../System.dll 的路径，我会得到：

The given assembly name or codebase was invalid. (Exception from HRESULT: 0x80131047)

然后我尝试在 Python 脚本中使用 clr 进行导入：

import clr
clr.AddReference('System')
from System import DateTime

现在我得到：

Cannot import name DateTime

我哪里错了？为什么DateTime 不在System 中，为什么LoadAssembly 找不到System.dll？我是否需要明确地为 IronPython 设置一些搜索路径？是否找到无效的“系统”？

当我在 IronPython 解释器中测试时，这一切正常。

我仍然是Python的新手,所以我想弄清楚如何做到这一点并需要一些帮助.

我使用返回代码来验证我的内部函数是否成功返回.例如(来自内部库函数):

result = some_function(arg1,arg2)
if result != OK: return result

或(从主脚本级别):

result = some_function(arg1,arg2)
if result != OK: abort_on_error("Could not complete 'some_function': %s" % messages(result))

我可以将其降低到一行而不会让它变得不可读吗？

编辑:有些人认识到异常可能是更好的选择.我想仅为非常"特殊"的场景捕获保存异常.返回代码有时可能会失败,我认为在这种情况下使用异常通常是不好的做法.

我正在尝试用C#做一些我在Ruby中一直做的事情,我想知道最接近的是什么.

如果Enum不包含我的整数值的定义,我希望它默认为某个值.我可以在一行中做到这一点吗？

Ruby-ish赋值(两个例子):

namedStr = Enum.GetName(typeof(myEnum), enumedInt) || "DEFAULT"

要么

namedStr = Enum.GetName(typeof(myEnum), enumedInt)
namedStr ||= "DEFAULT"

我有一个函数包含对我的一个套接字类型的调用.如果有错误,我希望能够打印警告并重试.在警告中,我想要方法名称.但是,它被宣布为lambda.这甚至可能吗？

我如何调用该函数(假设在函数myMain中):

SafeSocketCommand(() => this.mySocket.ReadCurrentBuffer());

基本包装功能:

protected TResult SafeSocketCommand<TResult>(Func<TResult> socketCommand)
{
    TResult retValue = default(TResult);
    try
    {
        retValue = socketCommand();
    }
    catch (PacketLost)
    {
        ReportToLogs("Timeout on command '" + socketCommand.Method.Name);
    }
    return retValue;
}

但socketCommand.Method.Name为我提供了调用方法(来自Stack Trace？)'<myMain> b__3',我希望socketCommand(mySocket.ReadCurrentBuffer)调用实际函数.是否可以在任何地方获取此信息,或者由于在lambda中声明而丢失？

编辑:

我应该提到我使用这个特定的调用约定,以便我可以使用各种签名的基于套接字的命令.

int i = SafeSocketCommand(() => this.mySocket.FunctionReturnsInt())
bool b = SafeSocketCommand(() => this.mySocket.FunctionReturnsBool(string s))
object o = SafeSocketCommand(() => this.mySocket.Complicated(string s, int i, bool b))

它还通过重载处理没有返回类型的签名:

protected void SafeSocketCommand(Action socketCommand)
{
    SafeSocketCommand(() => { socketCommand(); return 0; });
}