精华内容
下载资源
问答
  • 2020-03-14 14:11:45

    marshal:直译为“编排”, 在计算机中特 指将数据按某种描述格式编排出来,通常来说一般是从非文本格式到文本格式的数据转化。unmarshal自然是指marshal的逆过程。比如在WebService中,我们需要把java对象以xml方式表示并在网络间传输,把java对象转化成xml片段的过程就是marshal.

    更多相关内容
  • Marshal类的PtrToStructure

    2021-01-08 02:48:58
    PtrToStructure,将数据从非托管内存块封送到新分配的指定类型的托管对象 应用:MFC发送消息到WPF界面上 public IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled) ...
  • 今天小编就为大家分享一篇golang json.Marshal 特殊html字符被转义的解决方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 本文实例讲述了python使用marshal模块序列化的方法,分享给大家供大家参考。具体方法如下: 先来看看下面这段代码: import marshal data1 = ['abc',12,23,'jb51'] #几个测试数据 data2 = {1:'aaa',"b":'dad'} data...
  • 雷迪斯元帅 额外资源 当前数据类型支持 弦乐 清单 套装 散列 排序集 位图和HyperLogLogs 待办事项列表位于。...用Python2.7编写(Python3.x在JSON序列化上失败-正在处理)。... 所有依赖项都包含在源中(不需要pip...
  • Marshal

    2021-04-23 10:12:19
    C# Marshal C#Marshal 是操作指针类型的帮助类 。C#指针类型 什么是指针呢? 指针就是用户将数据存储到内存中的一个地址对象,可以根据指针获取实际的数据 C#指针用法 创建存储空间分配存在空间 intPtr C#指针对象 ...

    C# Marshal
    C#Marshal 是操作指针类型的帮助类 。C#指针类型
    什么是指针呢?
    指针就是用户将数据存储到内存中的一个地址对象,可以根据指针获取实际的数据
    C#指针用法
    创建存储空间分配存在空间 intPtr C#指针对象
    在这里插入图片描述
    读取指针指向的内存数据,如果是普通字符串读法 PtrToStringAnsi
    如图一:
    在这里插入图片描述
    读取为16进制的字节码就不能用PtrToStringAnsi 读取需要用到一个类型转化 Marshal.Copy 将内存复制到指定类型中 四个参数,第一个intPtr 类型的指针对象,第二个需要复制到类型中,第三个起始长度 第四个最大长度
    在这里插入图片描述
    用完释放指针资源
    在这里插入图片描述

    展开全文
  • 由于Remoting没有提供与之对应的Unregister方法来注销远程对象,所以如果需要注册/注销指定对象,微软推荐使用Marshal(一般译为编组)和Disconnect配对使用。在《Net Remoting基础篇》中我已经谈到:Marshal()方法...
  • 此工具将Python脚本转换为Base64,Marshal,Zlib格式。此工具仅用于教育目的。 [+]安装 apt update apt install git -y git clone https://github.com/htr-tech/Pycompile cd Pycompile python2 compile.py ...
  • 派克语法 从marshal.c生成.pyc字节码的语法描述。
  • Marshal类的使用

    2014-04-17 23:13:26
    Marshal类的简单使用,博客:http://blog.csdn.net/dingxiaowei2013/article/details/23934693
  • C#—EMguCV Marshal

    2018-05-09 11:14:17
    将数据从托管对象封送到非托管内存块,属于.NET Framework 类库
  • 注意: marshal并不是一个通用的模块,在某些时候它是一个不被推荐使用的模块,因为使用marshal序列化的二进制数据格式还没有文档化,在不同版本的Python中,marshal的实现可能不一样。也就是说,用python2.5序列为...
  • Marshal格式

    2021-03-25 11:04:31
    Marshal格式2002-04-04 草稿....以4.8(对应于1.8)版的格式为蓝本# 截至2003-05-02为止的格式版本如下所示p Marshal.Dump(Object.new).unpack("cc").join(".")=> ruby 1.6.0 (2000-09-19) [i586-linux]"4.4"=> ...

    Marshal格式

    2002-04-04 草稿....

    以4.8(对应于1.8)版的格式为蓝本

    # 截至2003-05-02为止的格式版本如下所示

    p Marshal.Dump(Object.new).unpack("cc").join(".")

    => ruby 1.6.0 (2000-09-19) [i586-linux]

    "4.4"

    => ruby 1.6.1 (2000-09-27) [i586-linux]

    "4.4"

    => ruby 1.6.2 (2000-12-25) [i586-linux]

    "4.5"

    => ruby 1.6.3 (2001-03-19) [i586-linux]

    "4.5"

    => ruby 1.6.4 (2001-06-04) [i586-linux]

    "4.5"

    => ruby 1.6.5 (2001-09-19) [i586-linux]

    "4.6"

    => ruby 1.6.6 (2001-12-26) [i586-linux]

    "4.6"

    => ruby 1.6.7 (2002-03-01) [i586-linux]

    "4.6"

    => ruby 1.6.7 (2002-09-06) [i586-linux]

    "4.6"

    => ruby 1.7.3 (2002-09-06) [i586-linux]

    "4.7"

    => ruby 1.7.3 (2002-09-20) [i586-linux]

    "4.8"

    => ruby 1.8.0 (2003-08-03) [i586-linux]

    "4.8"

    本文兼顾了以前的版本,同时也指出了兼容性问题

    还提到了Ruby的Marshal中的BUG(?)

    nil

    true

    false

    分别是'0', 'T', 'F'

    p Marshal.Dump(nil).unpack("x2 a*")

    # => ["0"]

    此时,即使设置了实例变量也无法Dump。

    class NilClass

    attr_accessor :foo

    end

    nil.foo = 1

    p nil.foo # => 1

    p Marshal.Dump(nil).unpack("x2 a*") # => ["0"]

    Fixnum

    在'i'之后是表示Fixnum的数据结构。

    以数值n为例,在表示数值部分的形式中(不仅限于Fixnum,在其它地方也是如此),保存着

    形式 1:

    n == 0: 0

    0 < n < 123: n + 5

    -124 < n < 0: n - 5

    这样的数值(1 byte)。之所以加减5,是为了有别于下面的形式。

    例:

    p Marshal.Dump(-1).unpack("x2 a*") # => "i\372"

    p Marshal.Dump(0).unpack("x2 a*") # => "i\000"

    p Marshal.Dump(1).unpack("x2 a*") # => "i\006"

    p Marshal.Dump(2).unpack("x2 a*") # => "i\a" ("i\007")

    若数值N超出形式1的范围时,则有下面的形式。

    形式 2:

    | len | n1 | n2 | n3 | n4 |

    byte bytes

    len的值是-4 ~ -1, 1 ~ 4。这表示符号和后续的数据存在于n1 ~ n|len|。

    # 举个更好的例子...

    def foo(len, n1, n2 = 0, n3 = 0, n4 = 0)

    case len

    when -3; n4 = 255

    when -2; n3 = n4 = 255

    when -1; n2 = n3 = n4 = 255

    end

    n = (0xffffff00 | n1) &

    (0xffff00ff | n2 * 0x100) &

    (0xff00ffff | n3 * 0x10000) &

    (0x00ffffff | n4 * 0x1000000)

    # p "%x" % n

    n = -((n ^ 0xffff_ffff) + 1) if len < 0

    n

    end

    p Marshal.Dump(-125).unpack("x2 acC*") # => ["i", -1, 131]

    p foo(-1, 131)

    p Marshal.Dump(-255).unpack("x2 acC*") # => ["i", -1, 1]

    p foo(-1, 1)

    p Marshal.Dump(-256).unpack("x2 acC*") # => ["i", -1, 0]

    p foo(-1, 0)

    p Marshal.Dump(-257).unpack("x2 acC*") # => ["i", -2, 255, 254]

    p foo(-2, 255, 254)

    p Marshal.Dump(124).unpack("x2 acC*") # => ["i", 1, 124]

    p foo(1, 124)

    p Marshal.Dump(256).unpack("x2 acC*") # => ["i", 2, 0, 1]

    p foo(2, 0, 1)

    即使设定了实例变量,也无法Dump。

    class Fixnum

    attr_accessor :foo

    end

    99.foo = 1

    p 99.foo # => 1

    p 999.foo # => nil

    p Marshal.Dump(99).unpack("x2 ac") # => ["i", 104]

    instance of the user class

    'C': String, Regexp, Array, Hash 的子类的实例变量

    | 'C' | 类名(Symbol)的 Dump | 父类的实例的 Dump |

    例 1:

    class Foo < String # (or Regexp, Array, Hash)

    end

    p Marshal.Dump(Foo.new("foo")).unpack("x2 a a c a3 aca*")

    # => ["C", ":", 8, "Foo", "\"", 8, "foo"]

    ^^^ (or '/', '[', '{')

    例 2: 有实例变量(请参考instance variable)

    class Foo < String # (or Regexp, Array, Hash)

    def initialize(obj)

    @foo = obj

    super(obj)

    end

    end

    p Marshal.Dump(Foo.new("foo")).unpack("x2 a a a c a3 aca3 caca4 aca*")

    # => ["I", "C", ":", 8, "Foo", "\"", 8, "foo", 6, ":", 9, "@foo", "\"", 8, "foo"]

    除此以外,将变为'o'。这是因为内部结构有所差异所致(请参考Object)

    例:

    class Foo

    end

    p Marshal.Dump(Foo.new).unpack("x2 a a c a*")

    # => ["o", ":", 8, "Foo\000"]

    'u'

    若定义了_Dump、_load的话,就是'u'。因为无法Dump实例变量,所以必须使用_Dump/_load进行处理。

    | 'u' | 类名(Symbol)的 Dump | _Dump 的结果的长度(Fixnum形式) |

    | _Dump 的返回值 |

    例:

    class Foo

    def self._load

    end

    def _Dump(obj)

    "hogehoge"

    end

    end

    p Marshal.Dump(Foo.new).unpack("x2 a aca3 c a*")

    # => ["u", ":", 8, "Foo", 13, "hogehoge"]

    'U' ruby 1.8 特性

    若定义了marshal_Dump、marshal_load的话,就是'U'。因为无法Dump实例变量,所以必须使用marshal_Dump/marshal_load来处理。

    | 'U' | 类名(Symbol)的 Dump | marshal_Dump 方法的返回值的 Dump |

    例:

    class Foo

    def marshal_Dump

    "hogehoge"

    end

    def marshal_load(obj)

    end

    end

    p Marshal.Dump(Foo.new).unpack("x2 a aca3 a c a*")

    # => ["U", ":", 8, "Foo", "\"", 13, "hogehoge"]

    Object

    'o'

    | 'o' | 类名(Symbol)的 Dump | 实例变量的数量(Fixnum形式) |

    | 实例变量名(Symbol) 的Dump(1) | 值(1) |

    :

    :

    | 实例变量名(Symbol) 的Dump(n) | 值(n) |

    例 1:

    p Marshal.Dump(Object.new).unpack("x2 a a c a*")

    # => ["o", ":", 11, "Object\000"]

    例 2: 有实例变量

    class Foo

    def initialize

    @foo = "foo"

    @bar = "bar"

    end

    end

    p Marshal.Dump(Foo.new).unpack("x2 a a c a3 c aca4 aca3 aca4 aca3")

    # => ["o", ":", 8, "Foo", 7,

    ":", 9, "@bar", "\"", 8, "bar",

    ":", 9, "@foo", "\"", 8, "foo"]

    Float

    'f'

    | 'f' | 数串的长度(Fixnum形式) | "%.16g" 的字符串 |

    例:

    p Marshal.Dump(Math::PI).unpack("x2 a c a*")

    # => ["f", 22, "3.141592653589793"]

    p Marshal.Dump(0.0/0).unpack("x2 a c a*") # => ["f", 8, "nan"]

    p Marshal.Dump(1.0/0).unpack("x2 a c a*") # => ["f", 8, "inf"]

    p Marshal.Dump(-1.0/0).unpack("x2 a c a*") # => ["f", 9, "-inf"]

    p Marshal.Dump(-0.0).unpack("x2 a c a*") # => ["f", 9, "-0"]

    Bignum

    'l'

    | 'l' | '+'/'-' | short的个数(Fixnum形式) | ... |

    例:

    p Marshal.Dump(2**32).unpack("x2 a a c a*")

    # => ["l", "+", 8, "\000\000\000\000\001\000"]

    # => ["l", "+", 8, "\000\000\001\000"]

    String

    '"'

    | '"' | 长度(Fixnum形式) | 字符串 |

    例:

    p Marshal.Dump("hogehoge").unpack("x2 a c a*")

    # => ["\"", 13, "hogehoge"]

    Regexp

    '/'

    | '/' | 长度(Fixnum形式) | source字符串 | 选项 |

    选项是 options的结果+汉字代码的flag值。

    例:

    p Marshal.Dump(/(hoge)*/).unpack("x2 a c a7 c")

    # => ["/", 12, "(hoge)*", 0]

    p Marshal.Dump(/hogehoge/m).unpack("x2 a c a8 c")

    # => ["/", 13, "hogehoge", 4]

    p Marshal.Dump(/hogehoge/e).unpack("x2 a c a8 c")

    # => ["/", 13, "hogehoge", 32]

    Array

    '['

    | '[' | 元素数(Fixnum形式) | 元素的 Dump | ... |

    例:

    p Marshal.Dump(["hogehoge", /hogehoge/]).unpack("x2 a c aca8 aca*")

    # => ["[", 7, "\"", 13, "hogehoge", "/", 13, "hogehoge\000"]

    Hash

    '{'

    | '{' | 元素数(Fixnum形式) | 键的 Dump | 值的 Dump | ... |

    例:

    p Marshal.Dump({"hogehoge", /hogehoge/}).unpack("x2 a c aca8 aca*")

    # => ["{", 6, "\"", 13, "hogehoge", "/", 13, "hogehoge\000"]

    Hash with default value ( not Proc )

    '}'

    | '}' | 元素数(Fixnum形式) | 键的 Dump | 值的 Dump | ... | 默认值 |

    例:

    h = Hash.new(true)

    h["foo"] = "bar"

    p Marshal.Dump(h).unpack("x2 a c aca3 aca*")

    # => ["}", 6, "\"", 8, "foo", "\"", 8, "barT"]

    若某Hash的默认对象是Proc的话,则无法Dump该Hash

    h = Hash.new { }

    Marshal.Dump(h)

    => -:2:in `Dump': cannot Dump hash with default proc (TypeError)

    Struct

    'S': 结构体类的实例的Dump

    | 'S' | 类名(Symbol) 的 Dump | 成员数量(Fixnum形式) |

    | 成员名(Symbol) 的 Dump | 值 | ... |

    例:

    Struct.new("XXX", :foo, :bar)

    p Marshal.Dump(Struct::XXX.new).unpack("x2 a ac a11 c aca3a aca3a")

    # => ["S", ":", 16, "Struct::XXX", 7,

    ":", 8, "foo", "0",

    ":", 8, "bar", "0"]

    Class/Module (old format)

    'M'

    | 'M' | 长度(Fixnum形式) | 模块/类名 |

    例: 因为已经无法dump这种形式,所以使用load进行说明。

    class Mod

    end

    p Marshal.load([4,7, 'M', 3+5, 'Mod'].pack("ccaca*"))

    # => Mod

    Class/Module

    'c', 'm'

    | 'c'/'m' | 类名的长度(Fixnum 形式) | 类名 |

    例:

    class Foo

    end

    p Marshal.Dump(Foo).unpack("x2 a c a*") # => ["c", 8, "Foo"]

    例 2: 无法dump类/模块的实例变量

    module Bar

    @bar = 1

    end

    p Bar.instance_eval { @bar }

    Marshal.Dump(Bar, open("/tmp/foo", "w"))

    # => 1

    module Bar

    end

    p bar = Marshal.load(open("/tmp/foo"))

    p bar.instance_eval { @bar }

    # => nil

    例 3: 无法dump类变量

    module Baz

    @@baz = 1

    def self.baz

    @@baz

    end

    end

    p Baz.baz

    Marshal.Dump(Baz, open("/tmp/foo", "w"))

    # => 1

    module Baz

    def self.baz

    @@baz

    end

    end

    p baz = Marshal.load(open("/tmp/foo"))

    baz.baz

    # => Baz

    -:3:in `baz': uninitialized class variable @@baz in Baz (NameError)

    from -:7

    Symbol

    ':'

    | ':' | 符号名的长度(Fixnum形式) | 符号名 |

    例:

    p Marshal.Dump(:foo).unpack("x2 a c a*")

    # => [":", 8, "foo"]

    Symbol (link)

    ';'

    | ';' | 表明Symbol实际状态的号码(Fixnum形式) |

    在相应符号名已被dump/load时使用。该号码是内部管理的号码。(在dump/load时,会生成哈希表以便对Symbol进行管理。它表示记录位置)

    例:

    p Marshal.Dump([:foo, :foo]).unpack("x2 ac aca3 aC*")

    # => ["[", 7, ":", 8, "foo", ";", 0]

    p Marshal.Dump([:foo, :foo, :bar, :bar]).

    unpack("x2 ac aca3 aC aca3 aC*")

    # => ["[", 9, ":", 8, "foo", ";", 0, ":", 8, "bar", ";", 6]

    instance variable

    'I': Object, Class, Module 的实例以外的对象

    | 'I' | 对象的 Dump | 实例变量的数量(Fixnum形式) |

    | 实例变量名(Symbol) 的Dump(1) | 值(1) |

    :

    :

    | 实例变量名(Symbol) 的Dump(n) | 值(n) |

    因为Object的实例中包含实例变量,所以会采用其他的形式进行Dump(请参考Object)。该形式只针对Array 或 String 的实例。

    例:

    obj = String.new

    obj.instance_eval { @foo = "bar" }

    p Marshal.Dump(obj).unpack("x2 a ac c a c a4 aca*")

    # => ["I", "\"", 0, 6, ":", 9, "@foo", "\"", 8, "bar"]

    类或模块(Class/Module的实例)不会dump实例变量的信息。(请参考Class/Module)

    link

    '@'

    | '@' | 表明对象实际状态的号码(Fixnum形式 |

    在相应对象已被dump/load时使用。该号码是内部管理的号码。(在dump/load时,会生成哈希表以便对对象进行管理。它表示记录位置)

    例:

    obj = Object.new

    p Marshal.Dump([obj, obj]).unpack("x2 ac aaca6c aca*")

    # => ["[", 7, "o", ":", 11, "Object", 0, "@", 6, ""]

    ary = []

    ary.push ary

    p Marshal.Dump(ary).unpack("x2 acac")

    # => ["[", 6, "@", 0]

    Marshal 的BUG

    在ruby version 1.6中发现了下列BUG。括号()中列出的是正确的运作方式(1.7的运作方式)。

    <= 1.6.7

    类的clone中的实例是可以Dump的,但却不能加载(因为是无名类的对象,所以无法Dump)

    当某对象通过include/extend无名Module而定义了特殊方法后,仍可以Dump/加载该对象(若某对象include了无名模块的话,则不能Dump该对象)

    1.6.6, 1.6.7

    拥有实例变量的Array和String是可以Dump的,但却不能加载(既能Dump,又能加载)

    <= 1.6.5

    类的clone中的实例是可以Dump的,但却不能正常加载。否则就会生成奇怪的对象(?)

    特殊类被dump成为普通类了(特殊类是无法Dump的)

    无名类是可以Dump的,但却不能加载(无名类是无法Dump的)

    <= 1.6.4

    模块可以Dump却不能加载(可以加载)

    无名模块可以Dump却不能加载(无名模块是不能Dump的)

    <= 1.6.3

    dump Float时,其保存精度偏低

    <= 1.6.2

    dump时,无法保存正则表达式中/m, /x 选项的状态

    1.6.2, 1.6.3

    在1.6.2, 1.6.3中,Bignum可以Dump却不能加载。按理说其他版本也会有这个BUG,但因为没有测试脚本,所以无法证实。

    <= 1.6.1

    dump时无法保存Range中的特定标识,该标识表明该范围中是否包含终点

    下面就是测试脚本(请参考[RAA:RubyUnit])

    # test for Marshal for ruby version 1.6

    require 'rubyunit'

    $version_dependent_behavior = true

    # for test_userClass, test_userModule

    module UserModule

    def foo

    end

    end

    class UserClass

    def foo

    end

    end

    class TestMarshal < RUNIT::TestCase

    def assert_no_Dumpable(obj)

    ex = assert_exception(TypeError) {

    begin

    # Marshal.Dump will cause TypeError or ArgumentError

    Marshal.Dump obj

    rescue ArgumentError

    case $!.message

    when /can't Dump anonymous/,

    /cannot Dump hash with default proc/

    raise TypeError

    else

    raise "unknown error"

    end

    end

    }

    end

    def assert_Dumpable_but_not_equal(obj)

    obj2 = Marshal.load(Marshal.Dump(obj))

    assert(obj != obj2)

    assert_equals(obj.type, obj2.type)

    end

    def assert_Dumpable_and_equal(obj)

    obj2 = Marshal.load(Marshal.Dump(obj))

    assert_equals(obj, obj2)

    assert_equals(obj.type, obj2.type)

    # check values of instance variable

    ivars = obj.instance_variables

    ivars2 = obj2.instance_variables

    assert_equals(ivars, ivars2)

    while ivars.size != 0

    assert_equals(obj.instance_eval(ivars.shift),

    obj2.instance_eval(ivars2.shift))

    end

    end

    def test_Object

    assert_Dumpable_but_not_equal Object.new

    end

    # object with singleton method

    def test_Object_with_singleton_method

    obj = Object.new

    # On ruby version 1.6.0 - 1.6.2, cause parse error (nested method)

    class <

    def foo

    end

    end

    # object has singleton method can't be Dumped

    assert_no_Dumpable obj

    end

    # object with singleton method (with named module)

    def test_Object_with_singleton_method2

    obj = Object.new

    # On ruby version 1.6.0 - 1.6.2, cause parse error (nested method)

    class <

    include UserModule

    end

    # On ruby version 1.6.0 - 1.6.7, no consider the singleton

    # method with Mix-in.

    # On ruby version 1.7, Dumpable object which is extended by

    # named module.

    assert_Dumpable_but_not_equal obj

    end

    # object with singleton method (with anonymous module)

    def test_Object_with_singleton_method3

    obj = Object.new

    # On ruby version 1.6.0 - 1.6.2, cause parse error (nested method)

    class <

    include Module.new

    end

    if $version_dependent_behavior and RUBY_VERSION <= "1.6.7"

    # On ruby version 1.6.0 - 1.6.7, no consider the singleton method with Mix-in.

    assert_Dumpable_but_not_equal obj

    else

    # object has singleton method (with anonymous module) can't be Dumped

    assert_no_Dumpable obj

    end

    end

    # singleton class

    def test_singletonClass

    obj = Object.new

    # On ruby version 1.6.0 - 1.6.2, cause parse error (nested method)

    singleton_class = class <

    def foo

    end

    self

    end

    # singleton class can't be Dumped

    # On ruby version 1.6.0 - 1.6.5, singleton class be able to Dumped

    # as normal class.

    if $version_dependent_behavior and RUBY_VERSION <= "1.6.5"

    assert_equals(Object, Marshal.load(Marshal.Dump(singleton_class)))

    else

    assert_no_Dumpable singleton_class

    end

    end

    def test_Array

    assert_Dumpable_and_equal [1,"foo", :foo]

    end

    def test_Array_with_instance_variable

    ary = [1,"foo", :foo]

    ary.instance_eval{ @var = 1 }

    if $version_dependent_behavior and %w(1.6.6 1.6.7).member?(RUBY_VERSION)

    # On ruby version 1.6.6 - 1.6.7, Array(or String ...) has instance

    # variable is able to be Dumped, but can't load it.

    Dump = Marshal.Dump(ary)

    ex = assert_exception(ArgumentError) {

    Marshal.load(Dump)

    }

    else

    assert_Dumpable_and_equal ary

    end

    end

    def test_Binding

    assert_no_Dumpable binding

    end

    def test_Continuation

    assert_no_Dumpable callcc {|c| c}

    end

    def test_Data

    # assert_fail("")

    end

    def test_Exception

    assert_Dumpable_but_not_equal Exception.new("hoge")

    end

    def test_Dir

    assert_no_Dumpable Dir.open("/")

    end

    def test_FalseClass

    assert_Dumpable_and_equal false

    end

    def test_File__Stat

    assert_no_Dumpable File.stat("/")

    end

    def test_Hash

    assert_Dumpable_and_equal(1=>"1",2=>"2")

    # 1.7 feature.

    if $version_dependent_behavior and RUBY_VERSION >= '1.7.0'

    # On ruby version 1.7, hash with default Proc cannot be Dumped.

    # see [ruby-dev:15417]

    assert_no_Dumpable(Hash.new { })

    end

    end

    def test_IO

    assert_no_Dumpable IO.new(0)

    end

    def test_File

    assert_no_Dumpable File.open("/")

    end

    def test_MatchData

    assert_no_Dumpable(/foo/ =~ "foo" && $~)

    end

    def test_Method

    assert_no_Dumpable Object.method(:method)

    end

    def test_UnboundMethod

    assert_no_Dumpable Object.instance_method(:id)

    end

    def test_Module

    # On ruby version 1.6.0 - 1.6.4, loaded module is not a module.

    if $version_dependent_behavior and RUBY_VERSION <= '1.6.4'

    Dump = Marshal.Dump Enumerable

    ex = assert_exception(TypeError) {

    Marshal.load Dump

    }

    assert_matches(ex.message, /is not a module/)

    else

    assert_Dumpable_and_equal Enumerable

    end

    end

    def test_userModule

    # On ruby version 1.6.0 - 1.6.4, loaded module is not a module.

    if $version_dependent_behavior and RUBY_VERSION <= '1.6.4'

    # same as test_Module

    else

    # Note: this module must be defineed for Marshal.load.

    assert_Dumpable_and_equal(UserModule)

    end

    end

    def test_anonymousModule

    # On ruby version 1.6.0 - 1.6.4, anonymous class is able to be Dumped,

    # but loaded object is not identical.

    if $version_dependent_behavior and RUBY_VERSION <= '1.6.4'

    Dump = Marshal.Dump(Module.new)

    ex = assert_exception(ArgumentError) {

    Marshal.load Dump

    }

    assert_matches(ex.message, /can\'t retrieve anonymous class/)

    else

    assert_no_Dumpable Module.new

    end

    end

    def test_Class

    assert_Dumpable_and_equal Class

    end

    def test_userClass

    # Note: this class must be defineed for Marshal.load.

    assert_Dumpable_and_equal(UserClass)

    end

    def test_anonymousClass

    # On ruby version 1.6.0 - 1.6.5, anonymous class able to be Dumped,

    # but can't load it.

    if $version_dependent_behavior and RUBY_VERSION <= '1.6.5'

    Dump = Marshal.Dump(Class.new)

    ex = assert_exception(ArgumentError) {

    Marshal.load(Dump)

    }

    assert_matches(ex.message, /can\'t retrieve anonymous class/)

    else

    assert_no_Dumpable Class.new

    end

    end

    def test_clonedClass

    # On ruby version 1.6.0 - 1.6.7, instance of cloned class is able to

    # Dumped, but loaded object is not identical.

    # see [ruby-dev:14961]

    if $version_dependent_behavior

    if RUBY_VERSION <= '1.6.5'

    obj = String.clone.new("foo")

    Dump = Marshal.Dump(obj)

    obj2 = Marshal.load Dump

    assert(obj == obj2)

    assert(obj.type != obj2.type)

    assert(obj.type.inspect == obj2.type.inspect)

    elsif RUBY_VERSION <= '1.6.7'

    Dump = Marshal.Dump(String.clone.new("foo"))

    assert_exception(ArgumentError) {

    Marshal.load Dump

    }

    else

    assert_no_Dumpable String.clone.new("foo")

    end

    else

    # anonymous class can't be Dumped

    assert_no_Dumpable String.clone.new("foo")

    end

    end

    def test_Numeric

    # assert_fail("")

    end

    def test_Integer

    # assert_fail("")

    end

    def test_Fixnum

    assert_Dumpable_and_equal 100

    end

    def test_Bignum

    # derived from Rubicon

    assert_Dumpable_and_equal 123456789012345678901234567890

    assert_Dumpable_and_equal -123**99

    if $version_dependent_behavior and %w(1.6.2 1.6.3).member?(RUBY_VERSION)

    Dump = Marshal.Dump 2**32

    ex = assert_exception(ArgumentError) {

    Marshal.load(Dump)

    }

    assert_matches(ex.message, /marshal data too short/)

    else

    assert_Dumpable_and_equal 2**32

    end

    end

    def test_Float

    assert_Dumpable_and_equal 1.41421356

    # On ruby version 1.6.4, Dumped format changed from "%.12g" to "%.16g"

    if $version_dependent_behavior and RUBY_VERSION <= '1.6.3'

    assert_Dumpable_but_not_equal Math::PI

    else

    assert_Dumpable_and_equal Math::PI

    end

    end

    def test_Proc

    assert_no_Dumpable proc { }

    end

    def test_Process__Status

    assert_Dumpable_and_equal system("true") && $?

    end

    def test_Range

    # Range#== is changed from 1.6.2

    # On ruby version 1.6.0 - 1.6.1, Range.new(1,2) != Range.new(1,2)

    # assert_Dumpable_and_equal 1..2

    # assert_Dumpable_and_equal 1...2

    obj = Marshal.load(Marshal.Dump 1..2)

    assert_equals(1, obj.begin)

    assert_equals(2, obj.end)

    assert_equals(false, obj.exclude_end?)

    obj = Marshal.load(Marshal.Dump 1...2)

    assert_equals(1, obj.begin)

    assert_equals(2, obj.end)

    # On ruby version 1.6.0 - 1.6.1, the attribute exclude_end? is not saved.

    if $version_dependent_behavior and RUBY_VERSION <= '1.6.1'

    assert_equals(false, obj.exclude_end?)

    else

    assert_equals(true, obj.exclude_end?)

    end

    end

    def test_Regexp

    # this test is no consider the /foo/p

    assert_Dumpable_and_equal /foo/

    assert_Dumpable_and_equal /foo/i

    assert_Dumpable_and_equal /foo/m

    assert_Dumpable_and_equal /foo/x

    assert_Dumpable_and_equal /foo/e

    assert_Dumpable_and_equal /foo/s

    assert_Dumpable_and_equal /foo/u

    # On ruby version 1.6.0 - 1.6.2, Regexp#== is ignore the option.

    for obj in [/foo/, /foo/i, /foo/m, /foo/x, /foo/e, /foo/s, /foo/u]

    obj2 = Marshal.load(Marshal.Dump obj)

    if $version_dependent_behavior and RUBY_VERSION <= '1.6.2' and

    %w(/foo/m /foo/x).member?(obj.inspect)

    # On ruby version 1.6.0 - 1.6.2,

    # //m options is not saved.

    assert_equals('/foo/', obj2.inspect)

    else

    assert_equals(obj.inspect, obj2.inspect)

    end

    end

    end

    def test_String

    assert_Dumpable_and_equal "foo"

    end

    def test_Struct

    assert_Dumpable_and_equal Struct.new("Foo", :foo, :bar)

    Object.const_set('Foo', Struct.new(:foo, :bar))

    assert_Dumpable_and_equal Foo

    end

    def test_aStruct

    assert_Dumpable_and_equal Struct.new("Bar", :foo, :bar).new("foo", "bar")

    # see [ruby-dev:14961]

    end

    def test_Symbol

    assert_Dumpable_and_equal :foo

    end

    def test_Thread

    assert_no_Dumpable Thread.new { sleep }

    end

    def test_ThreadGroup

    assert_no_Dumpable ThreadGroup::Default

    end

    def test_Time

    assert_Dumpable_and_equal Time.now

    assert_Dumpable_and_equal Time.now.gmtime

    # time zone is not saved.

    assert_equals(false, Marshal.load(Marshal.Dump(Time.now)).utc?)

    assert_equals(false, Marshal.load(Marshal.Dump(Time.now.gmtime)).utc?)

    end

    def test_TrueClass

    assert_Dumpable_and_equal true

    end

    def test_NilClass

    assert_Dumpable_and_equal nil

    end

    end

    展开全文
  • Marshal.copy 崩溃问题

    2021-03-22 11:20:35
    在执行Marshal.Copy的时候,崩溃,使用try catch完全捕获不到,进程直接退出了。代码如下: <code>public static bool ImageMirrorCv(ref int[] image, int width, int height, int ...
  • Marshal用法汇总

    千次阅读 2019-10-10 09:07:13
    使用sizeof的方法来确定缓冲区所需的字节数:DIM MYVARIABLE为点MyVariable.X = 100MyVariable.Y = 250DIM MyPointer作为IntPtr的Marshal.AllocHGlobal(Marshal.SizeOf(MYVARIABLE))Marshal.StructureToPtr...

    简介

    (https://www.cnblogs.com/DragonX/p/3474251.html)
    (https://www.cnblogs.com/lfls128/p/4939232.html)
    在两个不同的实体(两个线程或者进程甚至机器、在Managed和Unmanaged之间、托管和非托管之间)进行方法调用和参数传递的时候,具体的调用方法和参数的内存格式可能需要一定的转换,这个转换的过程叫做Marshal。

    Marshal就是把一个结构(类)序列化成一段内存,然后送到另一个进程(.net中Application domain)中供另一个进程中的函数使用。
    比如你的一个结构

    struct{
    Pen pen;
    }s;
    s是一个指向已有的Pen对象的引用,当你把s传给本进程中的一个函数f时,f可以很容易地找到pen的实际对象,但如果你把s传到另外一个进程时,甚至是另外一台机器上的进程时,这个进程就没办法找到pen的实际内容。Marshal技术则可以把pen对象中的所有实际内容按规则放到一个缓冲中,(所有的引用或指针都要转换成实际对象)然后把缓冲中的内容送到另一个进程,函数调用完成再用同样方式把结果返回来。
    在RPC,Interop,COM中Marshal应用很多。

    //特别注意:Marshal.PtrToStringAuto方法:分配托管 String,并从非托管内存中存储的字符串向其复制第一个空字符之前的所有字符。1public struct ImageDataMsg 
    { 
    public char DataType; 
    public int Srv_index; 
    public char ConvertType; 
    //这个个地方要指定长度,这样就可以得到结构体的正确长度了 
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 10)] 
    public int[] VecLayer;//需要那几个图层。 
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 10)] 
    public int[] GridLayer;//需要那几个栅格图层 
    public int Scale_index;//需要的是那个比例尺的图像 
    public int x_pos; 
    public int y_pos; 
    public int ClientArea_x; 
    public int ClientArea_y; 
    } 
    //使用这个方法将你的结构体转化为bytes数组 
    public static byte[] Struct2Bytes(ImageDataMsg obj) 
    { 
    int size = Marshal.SizeOf(obj); 
    byte[] bytes = new byte[size]; 
    try 
    { 
    IntPtr ptr = Marshal.AllocHGlobal(size); 
    Marshal.StructureToPtr(obj, ptr, false); 
    Marshal.Copy(ptr, bytes, 0, size); 
    Marshal.FreeHGlobal(ptr); 
    return bytes; 
    } 
    catch (Exception ee) 
    { 
    MessageBox.Show(ee.Message); 
    return bytes; 
    } 
    } 
    
    //使用这个方法将byte数组转化为结构体 
    public static object BytesToStuct2(byte[] bytes, ImageDataMsg type) 
    { 
    //得到结构体的大小 
    int size = Marshal.SizeOf(type); 
    //byte数组长度小于结构体的大小 
    if (size > bytes.Length) 
    { 
    //返回空 
    return null; 
    } 
    //分配结构体大小的内存空间 
    IntPtr structPtr = Marshal.AllocHGlobal(size); 
    //将byte数组拷到分配好的内存空间 
    Marshal.Copy(bytes, 0, structPtr, size); 
    //将内存空间转换为目标结构体 
    object obj = Marshal.PtrToStructure(structPtr, typeof(ImageDataMsg)); 
    //释放内存空间 
    Marshal.FreeHGlobal(structPtr); 
    //返回结构体 
    return obj; 
    }
    

    Marshal 类提供了一个方法集,这些方法用于分配非托管内存、复制非托管内存块、将托管类型转换为非托管类型,此外还提供了在与非托管代码交互时使用的其他杂项方法。

    Marshal 类中有许多成员,但他们大多是公用事业援助COM代码进行互操作。

    使用.NET,Visual Basic中有很大的权力,以至于处理在与 Windows 系统较低水平层次,并从外部库的非托管代码的工作。这权力是发现了三个新的工具:IntPtr的,NET的平台相关的内存地址代表性的GCHandle,从而你针和检索的管理内存堆的数据的地址; Marshal类的一站式。您的内存分配,清理,和操作的需要。
    如果您决定与VB.NET直接内存操作,你需要了解的第一件事是IntPtr类型。

    IntPtr 的是一个结构,它表示两个地址和处理(大多数处理 Windows 的指针的指针)。

    IntPtr 的实例也依赖于平台的(或独立,取决于你的观点)。在32位系统,IntPtr 的是32位,而在64位系统 IntPtr 的是64位。这样做的好处是,你不需要更改或重新编译你的代码,或两个平台内的任何.NET Framework的公开的方式与地址和处理工作的功能。

    使用 IntPtr 类型,这种功能是封送到非托管代码,仅仅作为内部地址编号,这意味着你可以通过一个 IntPtr 类型的变量的任何非托管代码的预计指针。因此,好消息是,虽然你不能在VB.NET中使用这样的: 如void * Dim MyPointer 这个工程精辟VB.NET:作为 IntPtr 的 DIM MyPointer
    请注意,在Beta 1没有IntPtr类型??相反,工作指针和处理使用 Integer 类型。

    IntPtr 类型有 ToInt32 方法的地址转换为一个整数,但可以将导致在64位系统的溢出异常。 IntPtr 也有 ToInt64 方法,但你必须保持跟踪的平台,如果你想要做的这些转换。StrPtr()和 VarPtr()NBSP在 VB.NET 这两个无证 VB 的6个功能变量的返回地址。相同的功能,可以在VB.NET的GCHandle类。

    让我们来看看如何放到一个 IntPtr 变量的地址。您可以使用的 GCHandle 的类,它有一个 AddrOfPinnedObject 的方法返回一个变量一个IntPtr。

    您必须"针"的数据,然后才可以得到这个地址。这可以防止不经意间移动数据的垃圾收集器,而你指的是原来的地址。这代码引脚一个变量,其地址显示在控制台窗口,并释放句柄:"昏暗的管理变量DIM MyString的字符串=阿德南塞缪尔? "针变量和创建"GC的处理实例昏暗的GH(MyString中,GCHandleType.Pinned)的GCHandle = GCHandle.Alloc "得到的变量的地址DIM AddrOfMyString作为IntPtr的= gh.AddrOfPinnedObject() Console.WriteLine(AddrOfMyString.ToString()) "自由的处理,并脱离"变量gh.Free()说明AllocHGlobal和AllocCoTaskMem
    上的本机堆内部使用GlobalAlloc函数分配内存AllocHGlobal; AllocCoTaskMem,这是类似的,而是使用的COM内存管理器(CoTaskMemAlloc来)。这两个函数有一个参数,分配的字节数。这两个函数返回一个IntPtr,新分配的缓冲区的基地址。释放内存,您使用的FreeHGlobal或FreeCoTaskMem方法,取决于分配方法您使用。这些函数有一个参数,新分配的缓冲区的分配函数返回地址。
    使用WriteByte,WriteInt16,WriteInt32,或WriteInt64方法简单的数字数据写入到一个非托管的缓冲区。每个函数作为参数的写操作的目的地址和数值你想要写。这些功能也重载以允许可选的第三个参数指示从抵消所提供的地址,它可以是有用的,如果你试图填充数组元素或结构领域的内存,例如:"分配一些内存,并获得它的地址DIM MyPointer的IntPtr = Marshal.AllocHGlobal(4) "写入到该地址的数量255Marshal.WriteInt32(MyPointer,255) "一些更多的代码(调用"例如的非托管代码) "空闲内存Marshal.FreeHGlobal(MyPointer)
    您也可以使用提供的地址,而不是你自己分配的非托管代码:D​​IM MyPointer作为IntPtr的新的IntPtr([插入整数地址_ 从这里非托管代码)] Marshal.WriteInt32(MyPointer,255)
    反过来也有可能。你可以阅读简单的数字数据,从一个IntPtr地址使用的readByte ReadInt16,ReadInt32,并ReadInt64方法:DIM MyInteger为整数= Marshal.ReadInt32(MyPointer)字符串函数
    阅读和写作字符串相似,读,写简单的数字数据,有一个小的例外:你不先分配内存,然后写一个字符串。相反,在非托管内存中创建一个字符串的行为分配的空间,并返回字符串的地址。写有七个方法:StringToBSTR,StringToCoTaskMemAnsi,StringToCoTaskMemUni,StringToCoTaskMemAuto,StringToHGlobalAnsi,StringToHGlobalUni和StringToHGlobalAuto。 StringToCoTaskMemxxx功能字符串数据写入到COM分配的内存,而StringToHGlobalxxx功能写入到本地的非托管堆。结束在ANSI的函数写单字节ANSI字符串。结束在统一的函数写双字节的Unicode字符串。功能,自动结束写入ANSI或Unicode字符串,这取决于操作系统:Windows 98和ME,NT为基础的平台(Windows NT 4.0中,2000年,和XP)的Unicode字符串的ANSI字符串。 StringToBSTR写一个自动化BSTR,这是类似于使用SysAllocString函数。这些函数接受一个字符串作为输入参数,并返回一个指针,得到的字符串:DIM MyStrPointer的IntPtr = Marshal.StringToHGlobalAuto(quot;您好Worldquot;)
    四个读的方法呢??PtrToStringAnsi,PtrToStringUni,PtrToStringAuto,PtrToStringBSTR??在一个给定的地址读取数据,并创建一个托管String对象,其中包含的字符的副本。 PtrToStringAnsi如果非托管字符串是ANSI,PtrToStringUni如果非托管字符串是Unicode,或PtrToStringBSTR如果非托管字符串是BSTR类型。 PtrToStringAuto假定非托管字符串是一个Windows 98或ME系统的ANSI和Unicode的Windows NT 4.0,2000或XP平台上。 PtrToStringAuto实际上是调用PtrToStringAnsi或PtrToStringUni,取决于操作系统。每个函数重载接受一个可选的数字复制的字符。如果你没有提供的字符数,函数看起来为终止空字符:"复制整个字符串昏暗的MyString的字符串= Marshal.PtrToStringAuto(MyPointer)"复制前5个字符DIM MyString的字符串= Marshal.PtrToStringAuto(MyPointer,5)
    拿着一个字符串要释放非托管内存缓冲区,可以调用FreeHGlobal或FreeCoTaskMem成员。要免费StringToBSTR创建一个BSTR,你叫FreeBSTR,这反过来又调用FreeSysString功能。 - ; StructureToPtr和PtrToStructure
    你写的非托管内存结构(用户定义类型)使用的StructureToPtr方法。这种方法需要你有时间提前分配的内存缓冲区。它有三个参数:您要编写的结构,内存缓冲区的地址(IntPtr的),和一个删除标志。删除标志设置为True湿巾和释放任何现有的数据从缓冲区。这是非常重要的,因为你可能会导致内存泄漏不删除现有的缓冲空间。例如,如果结构的领域之一,是另一种结构或字符串的引用,数据被外地引用不会被释放,如果该参数设置为False。还要注意的是结构复制到非托管内存,使用特定的格式(你可以控制可选),和非托管的副本可能不像完全的托管表示。使用sizeof的方法来确定缓冲区所需的字节数:DIM MYVARIABLE为点MyVariable.X = 100MyVariable.Y = 250DIM MyPointer作为IntPtr的Marshal.AllocHGlobal(Marshal.SizeOf(MYVARIABLE))Marshal.StructureToPtr(MYVARIABLE,MyPointer,假)
    使用PtrToStructure方法扭转的过程和读从非托管内存结构。您可以使用此方法可以作为一个函数返回一个结构的副本类型的基础上,或填补了结构参数作为一个子。请注意,PtrToStructure返回一个Object类型的引用,和Option Strict On时,您必须转换为结构类型(例如,所使用的CType):作为点DIM MyPointMyPoint = CTYPE(Marshal.PtrToStructure(MyPointer的GetType(点)),点)复制方法
    读取和写入阵列中的数据,尤其是宝贵的,当你需要二进制数据流。 Copy方法读取和写入,根据您传递给它的参数。如果你想写入数据,你需要先分配一些缓冲区空间,就像你会使用字符串。接下来,您呼叫的复制方法,并通过数组本身,目的地址(IntPtr的分配),你要开始复制的元素的数组的索引,和缓冲区的大小:DIM MyData的(255)作为字节"在这里插入代码,以填补字节数组DIM BufferAddress的IntPtr = Marshal.AllocHGlobal(256)Marshal.Copy(MYDATA,0,BufferAddress,256)
    要阅读从非托管内存中的数组,调用复制的方法,并通过缓冲区的地址(IntPtr的),你想从缓冲区中的数据填充数组,数组的索引,你要开始复制到了,你要复制的数据的大小:MyData的DIM(255)以字节 Marshal.Copy(BufferAddress,MYDATA,0,256)
    Marshal类中有更多的方法,但他们大多是公用事业援助COM代码进行互操作。结论
    这些功能也相当有助于封送处理以及asnbsp管理的数据; CopyMemory如非托管的内存也被称为RtlMoveMomry功能的一个很好的替代。
    我总是乐于帮助,因此,如果您有任何疑问,或对我的文章建议,感到自由。您还可以在MSN Messenger上达到我的屏幕名称千里马吗??

    展开全文
  • Marshal 一、功能介绍 实现官方encoding/json包的marshal功能的简化版,实现将结构体转化为json格式字符流 支持int、string、struct、interface、ptr、map形式的数据类型 支持tag标签来实现字段重命名以及字段...
  • marshal 对象的序列化

    2021-02-26 20:03:39
    有时候,要把内存中的一个对象持久化保存到磁盘上,或者...注意:marshal并不是一个通用的模块,在某些时候它是一个不被推荐使用的模块,因为使用marshal序列化的二进制数据格式还没有文档化,在不同版本的Python...
  • ex_marshal:在Elixir中实现的Ruby Marshal格式
  • //从非托管内存中申请内存空间,并返会该内存块的地址 (单位:字节) //相当于byte[length] //注意:申请内存空间不会立即在任务管理器中显示内存占用情况 try { #region Marshal - 写入 { Marshal.WriteByte...
  • C#指针操作Marshal实例

    2021-04-29 17:33:19
    static void Main(string[] args) { byte[] a = new byte[]{0,0,0,0}; byte[] b = new byte[] {1,... IntPtr pt = Marshal.AllocHGlobal(a.Length); //从source数组的startIndex下标开始复制length个对象到ptr; ...
  • // 初始化一块非托管内存,大小为结构体所占的内存大小 IntPtr pnt = Marshal.AllocHGlobal(Marshal.SizeOf(p)); try { //将Point p的数据复制到非托管内存中去 Marshal.StructureToPtr(p, pnt, false); // Create ...
  • 小弟最近在研究利用Marshal实现序列化和反系列化,主要是使用Marshal类里的两个方法,StructureToPtr和PtrToStructure,这两个类的具体讲解和用法我就不多赘述 了,具体见[url=...[/url],下面说我碰到的问题,我的需求...
  • EOFError: marshal data too short 已解决 明明什么也没改,跑程序的时候就突然报这个错,import numpy都不行了…找了好久,知道要删掉__pycache__但是不知道删哪里的,其实很简单,找到最后的报错点,顺藤摸瓜就...
  • 测试Bitmap和Marshal.Copy

    2021-08-13 11:14:41
    #region 测试Bitmap和Marshal.Copy public static void TestBitmapAndMarshalCopy() { //测试Bitmap和Marshal.Copy Bitmap bitmap1 = new Bitmap("./123456.jpg"); Rectangle rectangle = new Rectangle(0, 0, ...
  • 主要是使用Marshal类里的两个方法: 第一个是StructureToPtr,将数据从托管对象封送到非托管内存块。 第二个是PtrToStructure,将数据从非托管内存块封送到新分配的指定类型的托管对象。 只要有了这两个相互转换...
  • /// /// /// /// public static IntPtr StructureToPtr(T structure) where T : new() { IntPtr buffer = Marshal.AllocHGlobal(Marshal.SizeOf(structure)); Marshal.StructureToPtr(structure, buffer, false); ...
  • OMERO元帅 可扩展的封送处理代码将各种OMERO...python virtualenv.py omero-marshal source omero-marshal/bin/activate pip install -r requirements.txt pip install -r requirements-dev.txt 运行测试 使用py.test运
  • GoLang Escape characters ...等以Unicode形式输出,如下形式:第一行代码是Marshal后的输出,但是有时候需要的是原格式的json,但是Golang中没有Python的Decode的功能,需要使用者自己转化。 "\u003cspan\u003e\u003cf

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 45,530
精华内容 18,212
关键字:

marshal

友情链接: 数据库连接(1).rar