I know that in terms of several distributed techniques (such as RPC), the term &quot;Marshaling&quot; is used but don&#39;t understand how it differs from Serialization. Aren&#39;t they both transforming objects into series of bits?

### Related:
[What is Serialization?](https://stackoverflow.com/questions/633402/what-is-serialization)

[What is Object Marshalling?](https://stackoverflow.com/questions/154185/what-is-object-marshalling)

What is the difference between Serialization and Marshaling?

In PHP there is [`func_num_args`](http://php.net/manual/en/function.func-num-args.php) and [`func_get_args`](http://php.net/manual/en/function.func-get-args.php), is there something similar for JavaScript?

Is it possible to get all arguments of a function as single object inside that function?

I am getting started with Object-Oriented Programming (OOP) and would like to know: what is the meaning of serialization in OOP parlance?

What is Serialization?

I wish to use the `&quot;encoding/json&quot;` package to marshal a struct declared in one of the imported packages of my application.

Eg.:

    type T struct {
        Foo int
    }

Because it is imported, all available (exported) fields in the struct begins with an upper case letter. But I wish to have lower case key names:

    out, err := json.Marshal(&amp;T{Foo: 42})

will result in

&gt; {&quot;Foo&quot;:42}

but I wish to get

&gt; {&quot;foo&quot;:42}

Is it possible to get around the problem in some easy way?

Lowercase JSON key names with JSON Marshal in Go

    type TestObject struct {
    	kind string `json:&quot;kind&quot;`
    	id   string `json:&quot;id, omitempty&quot;`
    	name  string `json:&quot;name&quot;`
    	email string `json:&quot;email&quot;`
    }
    
    func TestCreateSingleItemResponse(t *testing.T) {
    	testObject := new(TestObject)
    	testObject.kind = &quot;TestObject&quot;
    	testObject.id = &quot;f73h5jf8&quot;
    	testObject.name = &quot;Yuri Gagarin&quot;
    	testObject.email = &quot;Yuri.Gagarin@Vostok.com&quot;
    
    	fmt.Println(testObject)
    
    	b, err := json.Marshal(testObject)
    
    	if err != nil {
    		fmt.Println(err)
    	}
    
    	fmt.Println(string(b[:]))
    }


Here is the output:

    [ `go test -test.run=&quot;^TestCreateSingleItemResponse$&quot;` | done: 2.195666095s ]
    	{TestObject f73h5jf8 Yuri Gagarin Yuri.Gagarin@Vostok.com}
    	{}
    	PASS


Why is the JSON essentially empty?

json.Marshal(struct) returns &quot;{}&quot;

The question is a bit theoretical, what is the cost of creating JAXB context, marshaller and unmarshaller?

I&#39;ve found that my code could benefit from keeping the same JAXB context and possibly the same marshaller for all marshaling operations rather than creating context and marshaller on each marshaling.

So what is the cost of creating JAXB context and marshaller/unmarshaller? Is it okay to create context+marshaller for each marshaling operation or it&#39;s better to avoid it?


JAXB creating context and marshallers cost

What is marshalling and why do we need it?

I find it hard to believe that I cannot send an `int` over the wire from C# to C and have to marshall it. Why can&#39;t C# just send the 32 bits over with a starting and terminating signal, telling C code that it has received an `int`?

&lt;sub&gt;If there are any good tutorials or sites about why we need marshalling and how to use it, that would be great.&lt;/sub&gt;

Marshaling – what is it and why do we need it?

I have a small hierarchy of objects that I need to serialize and transmit via a socket connection.  I need to both serialize the object, then deserialize it based on what type it is.  Is there an easy way to do this in C++ (as there is in Java)?

Are there any C++ serialization online code samples or tutorials?

**EDIT:** Just to be clear, I&#39;m looking for methods on converting an object into an array of bytes, then back into an object.  I can handle the socket transmission.


How do you serialize an object in C++?

Whenever I call `ElementTree.tostring(e)`, I get the following error message:

    AttributeError: &#39;Element&#39; object has no attribute &#39;getroot&#39;

Is there any other way to convert an ElementTree object into an XML string?

TraceBack:

    Traceback (most recent call last):
      File &quot;Development/Python/REObjectSort/REObjectResolver.py&quot;, line 145, in &lt;module&gt;
        cm = integrateDataWithCsv(cm, csvm)
      File &quot;Development/Python/REObjectSort/REObjectResolver.py&quot;, line 137, in integrateDataWithCsv
        xmlstr = ElementTree.tostring(et.getroot(),encoding=&#39;utf8&#39;,method=&#39;xml&#39;)
    AttributeError: &#39;Element&#39; object has no attribute &#39;getroot&#39;

Convert Python ElementTree to string

When JAXB marshals a date object (`XMLGregorianCalendar`) into an xsd:dateTime element. How can you specify the format of the resulting XML?

For example:
The default data format uses milliseconds `&lt;StartDate&gt;2012-08-21T13:21:58.000Z&lt;/StartDate&gt;`
I need to omit the milliseconds.  `&lt;StartDate&gt;2012-08-21T13:21:58Z&lt;/StartDate&gt;`

How can I specify the output form/date format that I want it to use?
I&#39;m using `javax.xml.datatype.DatatypeFactory` to create the `XMLGregorianCalendar` object.

    XMLGregorianCalendar xmlCal = datatypeFactory.newXMLGregorianCalendar(cal);
    



How do you specify the date format used when JAXB marshals xsd:dateTime?

What would be the best way to fill a C# struct from a byte[] array where the data was from a C/C++ struct?  The C struct would look something like this (my C is very rusty):

    typedef OldStuff {
        CHAR Name[8];
        UInt32 User;
        CHAR Location[8];
        UInt32 TimeStamp;
        UInt32 Sequence;
        CHAR Tracking[16];
        CHAR Filler[12];
    }

And would fill something like this:

    [StructLayout(LayoutKind.Explicit, Size = 56, Pack = 1)]
    public struct NewStuff
    {
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8)]
        [FieldOffset(0)]
        public string Name;

        [MarshalAs(UnmanagedType.U4)]
        [FieldOffset(8)]
        public uint User;

        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8)]
        [FieldOffset(12)]
        public string Location;

        [MarshalAs(UnmanagedType.U4)]
        [FieldOffset(20)]
        public uint TimeStamp;

        [MarshalAs(UnmanagedType.U4)]
        [FieldOffset(24)]
        public uint Sequence;

        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 16)]
        [FieldOffset(28)]
        public string Tracking;
    }

What is best way to copy `OldStuff` to `NewStuff`, if `OldStuff` was passed as byte[] array?

I&#39;m currently doing something like the following, but it feels kind of clunky.

    GCHandle handle;
    NewStuff MyStuff;

    int BufferSize = Marshal.SizeOf(typeof(NewStuff));
    byte[] buff = new byte[BufferSize];

    Array.Copy(SomeByteArray, 0, buff, 0, BufferSize);

    handle = GCHandle.Alloc(buff, GCHandleType.Pinned);
  
    MyStuff = (NewStuff)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(NewStuff));
  
    handle.Free();

Is there better way to accomplish this?

---

Would using the `BinaryReader` class offer any performance gains over pinning the memory and using `Marshal.PtrStructure`?

Reading a C/C++ data structure in C# from a byte array

I know this question has been asked, at least [here][1].

But there wasn&#39;t a satisfactory answer, at least not to me. There is a lot of talk about marshalling as regards interoperating with unmanaged code, but what about marshalling from one thread to another, as we have to do in .NET sometimes.

This makes me ask, what is marshalling, really? When you give a definition of marshalling, how would you define it so that it is explaining the case of interoperability, as well as the cases where you are &quot;marshalling&quot; between threads?


  [1]: https://stackoverflow.com/questions/2240804/marshalling-what-is-it-and-why-do-we-need-it

What is marshalling? What is happening when something is &quot;marshalled?&quot;

We have some interop code that involves matrices. I was trying to call the native DLL and for the most part it works very reliably.

I am relying on the [default marshalling by .net][1], avoiding unmanaged pointers and rather using .net arrays for the most part, and maybe a `byref` here and there. The .net article says, that multidimensional arrays are implicitly marshalled as column-major one-dimensional arrays, which would be fine. 

The only thing that does not seem to work, is trying to marshal a multi-dimensional array, as the F# compiler complains that `float[,]` is not allowed in an `extern` declaration. Is there any way around this limitation? 

I am aware of the `PinnedArray` and `PinnedArray2` types from the F# PowerPack, but I was looking for a solution which relies on managed pointers and - more importantly - I&#39;d like to avoid having to include F# PowerPack as a dependency just for the `PinnedArray` classes.


  [1]: http://msdn.microsoft.com/en-us/library/z6cfh6e6%28v=vs.110%29.aspx

How to marshal multi-dimensional arrays

From the [docs](https://golang.org/pkg/encoding/json/#Marshal):

&gt; JSON cannot represent cyclic data structures and Marshal does not handle them. Passing cyclic structures to Marshal will result in an infinite recursion.

I&#39;ve experienced this situation, which results in a runtime panic.

What I&#39;m wondering is if anyone can provide a working program that demonstrates a non-panic situation where json.Marshal returns a non-nil error. The best answers would **clearly include the inputs used**.

What input will cause golang&#39;s json.Marshal to return an error?

I have heard this concept used frequently, but I don&#39;t have a really good grasp of what it is.

What is object marshalling?

Question
========

I&#39;m porting a C application into C#. The C app calls lots of functions from a 3rd-party DLL, so I wrote P/Invoke wrappers for these functions in C#. Some of these C functions allocate data which I have to use in the C# app, so I used `IntPtr`&#39;s, [`Marshal.PtrToStructure`][1] and [`Marshal.Copy`][2] to copy the native data (arrays and structures) into managed variables. 

Unfortunately, the C# app proved to be much slower than the C version. A quick performance analysis showed that the above mentioned marshaling-based data copying is the bottleneck. **I&#39;m considering to speed up the C# code by rewriting it to use pointers instead.** Since I don&#39;t have experience with unsafe code and pointers in C#, I need expert opinion regarding the following **questions**:

1. What are the drawbacks of using `unsafe` code and pointers instead of `IntPtr` and `Marshal`ing? For example, is it more unsafe (pun intended) in any way? People seem to prefer marshaling, but I don&#39;t know why.
2. Is using pointers for P/Invoking really faster than using marshaling? How much speedup can be expected approximately? I couldn&#39;t find any benchmark tests for this.

Example code
============

To make the situation more clear, I hacked together a small example code (the real code is much more complex). I hope this example shows what I mean when I&#39;m talking about &quot;unsafe code and pointers&quot; vs. &quot;IntPtr and Marshal&quot;.

C library (DLL)
---------------

MyLib.h

    #ifndef _MY_LIB_H_
    #define _MY_LIB_H_
    
    struct MyData 
    {
      int length;
      unsigned char* bytes;
    };
    
    __declspec(dllexport) void CreateMyData(struct MyData** myData, int length);
    __declspec(dllexport) void DestroyMyData(struct MyData* myData);
    
    #endif // _MY_LIB_H_

MyLib.c

    #include &lt;stdlib.h&gt;
    #include &quot;MyLib.h&quot;
    
    void CreateMyData(struct MyData** myData, int length)
    {
      int i;
    
      *myData = (struct MyData*)malloc(sizeof(struct MyData));
      if (*myData != NULL)
      {
        (*myData)-&gt;length = length;
        (*myData)-&gt;bytes = (unsigned char*)malloc(length * sizeof(char));
        if ((*myData)-&gt;bytes != NULL)
          for (i = 0; i &lt; length; ++i)
            (*myData)-&gt;bytes[i] = (unsigned char)(i % 256);
      }
    }
    
    void DestroyMyData(struct MyData* myData)
    {
      if (myData != NULL)
      {
        if (myData-&gt;bytes != NULL)
          free(myData-&gt;bytes);
        free(myData);
      }
    }

C application
-------------

Main.c

    #include &lt;stdio.h&gt;
    #include &quot;MyLib.h&quot;
    
    void main()
    {
      struct MyData* myData = NULL;
      int length = 100 * 1024 * 1024;
    
      printf(&quot;=== C++ test ===\n&quot;);
      CreateMyData(&amp;myData, length);
      if (myData != NULL)
      {
        printf(&quot;Length: %d\n&quot;, myData-&gt;length);
        if (myData-&gt;bytes != NULL)
          printf(&quot;First: %d, last: %d\n&quot;, myData-&gt;bytes[0], myData-&gt;bytes[myData-&gt;length - 1]);
        else
          printf(&quot;myData-&gt;bytes is NULL&quot;);
      }
      else
        printf(&quot;myData is NULL\n&quot;);
      DestroyMyData(myData);
      getchar();
    }

C# application, which uses `IntPtr` and `Marshal`
-------------------------------------------------

Program.cs

    using System;
    using System.Runtime.InteropServices;
    
    public static class Program
    {
      [StructLayout(LayoutKind.Sequential)]
      private struct MyData
      {
        public int Length;
        public IntPtr Bytes;
      }
    
      [DllImport(&quot;MyLib.dll&quot;)]
      private static extern void CreateMyData(out IntPtr myData, int length);
    
      [DllImport(&quot;MyLib.dll&quot;)]
      private static extern void DestroyMyData(IntPtr myData);
    
      public static void Main()
      {
        Console.WriteLine(&quot;=== C# test, using IntPtr and Marshal ===&quot;);
        int length = 100 * 1024 * 1024;
        IntPtr myData1;
        CreateMyData(out myData1, length);
        if (myData1 != IntPtr.Zero)
        {
          MyData myData2 = (MyData)Marshal.PtrToStructure(myData1, typeof(MyData));
          Console.WriteLine(&quot;Length: {0}&quot;, myData2.Length);
          if (myData2.Bytes != IntPtr.Zero)
          {
            byte[] bytes = new byte[myData2.Length];
            Marshal.Copy(myData2.Bytes, bytes, 0, myData2.Length);
            Console.WriteLine(&quot;First: {0}, last: {1}&quot;, bytes[0], bytes[myData2.Length - 1]);
          }
          else
            Console.WriteLine(&quot;myData.Bytes is IntPtr.Zero&quot;);
        }
        else
          Console.WriteLine(&quot;myData is IntPtr.Zero&quot;);
        DestroyMyData(myData1);
        Console.ReadKey(true);
      }
    }

C# application, which uses `unsafe` code and pointers
-----------------------------------------------------

Program.cs

    using System;
    using System.Runtime.InteropServices;
    
    public static class Program
    {
      [StructLayout(LayoutKind.Sequential)]
      private unsafe struct MyData
      {
        public int Length;
        public byte* Bytes;
      }
    
      [DllImport(&quot;MyLib.dll&quot;)]
      private unsafe static extern void CreateMyData(out MyData* myData, int length);
    
      [DllImport(&quot;MyLib.dll&quot;)]
      private unsafe static extern void DestroyMyData(MyData* myData);
    
      public unsafe static void Main()
      {
        Console.WriteLine(&quot;=== C# test, using unsafe code ===&quot;);
        int length = 100 * 1024 * 1024;
        MyData* myData;
        CreateMyData(out myData, length);
        if (myData != null)
        {
          Console.WriteLine(&quot;Length: {0}&quot;, myData-&gt;Length);
          if (myData-&gt;Bytes != null)
            Console.WriteLine(&quot;First: {0}, last: {1}&quot;, myData-&gt;Bytes[0], myData-&gt;Bytes[myData-&gt;Length - 1]);
          else
            Console.WriteLine(&quot;myData.Bytes is null&quot;);
        }
        else
          Console.WriteLine(&quot;myData is null&quot;);
        DestroyMyData(myData);
        Console.ReadKey(true);
      }
    }


  [1]: http://msdn.microsoft.com/en-us/library/system.runtime.interopservices.marshal.ptrtostructure.aspx
  [2]: http://msdn.microsoft.com/en-us/library/system.runtime.interopservices.marshal.copy.aspx







C# performance - Using unsafe pointers instead of IntPtr and Marshal

I&#39;ve got a few classes that implement [Parcelable][1] and some of these classes contain each other as properties. I&#39;m marshalling the classes into a [Parcel][2] to pass them between activities. Marshalling them TO the Parcel works fine, but when I try to unmarshall them I get the following error:

    ...
    AndroidRuntime  E  Caused by: android.os.BadParcelableException: ClassNotFoundException when unmarshalling: schemas.Arrivals.LocationType
    AndroidRuntime  E  	at android.os.Parcel.readParcelable(Parcel.java:1822)
    AndroidRuntime  E  	at schemas.Arrivals.LayoverType.&lt;init&gt;(LayoverType.java:121)
    AndroidRuntime  E  	at schemas.Arrivals.LayoverType.&lt;init&gt;(LayoverType.java:120)
    AndroidRuntime  E  	at schemas.Arrivals.LayoverType$1.createFromParcel(LayoverType.java:112)
    AndroidRuntime  E  	at schemas.Arrivals.LayoverType$1.createFromParcel(LayoverType.java:1)
    AndroidRuntime  E  	at android.os.Parcel.readTypedList(Parcel.java:1509)
    AndroidRuntime  E  	at schemas.Arrivals.BlockPositionType.&lt;init&gt;(BlockPositionType.java:244)
    AndroidRuntime  E  	at schemas.Arrivals.BlockPositionType.&lt;init&gt;(BlockPositionType.java:242)
    AndroidRuntime  E  	at schemas.Arrivals.BlockPositionType$1.createFromParcel(BlockPositionType.java:234)
    AndroidRuntime  E  	at schemas.Arrivals.BlockPositionType$1.createFromParcel(BlockPositionType.java:1)
    ...

The `LayoverType` class (where it&#39;s failing):

    public class LayoverType implements Parcelable {    
        protected LocationType location;
        protected long start;
        protected long end;
    
        public LayoverType() {}
        
        public LocationType getLocation() {
            return location;
        }
    
        public void setLocation(LocationType value) {
            this.location = value;
        }
    
        public long getStart() {
            return start;
        }
    
        public void setStart(long value) {
            this.start = value;
        }
    
        public long getEnd() {
            return end;
        }
    
        public void setEnd(long value) {
            this.end = value;
        }
    
    
        // **********************************************
        //  for implementing Parcelable
        // **********************************************
        
        @Override
        public int describeContents() {
            return 0;
        }
    
        @Override
        public void writeToParcel(Parcel dest, int flags) {
            dest.writeParcelable(location, flags);
            dest.writeLong(start);
            dest.writeLong(end  );
        }
    
        public static final Parcelable.Creator&lt;LayoverType&gt; CREATOR = new Parcelable.Creator&lt;LayoverType&gt;() {
            public LayoverType createFromParcel(Parcel in) {
                return new LayoverType(in);
            }
    
            public LayoverType[] newArray(int size) {
                return new LayoverType[size];
            }
        };
        
        private LayoverType(Parcel dest) {
            location = (LocationType) dest.readParcelable(null);    // it&#39;s failing here
            start = dest.readLong();
            end   = dest.readLong();
        }
    }


Here&#39;s the `LocationType` class:

    public class LocationType implements Parcelable {
        protected int locid;
        protected String desc;
        protected String dir;
        protected double lat;
        protected double lng;
    
        public LocationType() {}
    
        public int getLocid() {
            return locid;
        }

        public void setLocid(int value) {
            this.locid = value;
        }

        public String getDesc() {
            return desc;
        }

        public void setDesc(String value) {
            this.desc = value;
        }

        public String getDir() {
            return dir;
        }

        public void setDir(String value) {
            this.dir = value;
        }

        public double getLat() {
            return lat;
        }

        public void setLat(double value) {
            this.lat = value;
        }

        public double getLng() {
            return lng;
        }

        public void setLng(double value) {
            this.lng = value;
        }

        // **********************************************
        //  for implementing Parcelable
        // **********************************************
    
    
        @Override
        public int describeContents() {
            return 0;
        }

        @Override
        public void writeToParcel(Parcel dest, int flags) {
            dest.writeInt   (locid);
            dest.writeString(desc );
            dest.writeString(dir  );
            dest.writeDouble(lat  );
            dest.writeDouble(lng  );
        }

        public static final Parcelable.Creator&lt;LocationType&gt; CREATOR = new Parcelable.Creator&lt;LocationType&gt;() {
            public LocationType createFromParcel(Parcel in) {
                return new LocationType(in);
            }
    
            public LocationType[] newArray(int size) {
                return new LocationType[size];
            }
        };
        
        private LocationType(Parcel dest) {
            locid = dest.readInt   ();
            desc  = dest.readString();
            dir   = dest.readString();
            lat   = dest.readDouble();
            lng   = dest.readDouble();
        }
    }

**Update 2**: As far as I can tell it&#39;s failing at the following bit of code (from [Parcel&#39;s source][3]):

    Class c = loader == null ? Class.forName(name) : Class.forName(name, true, loader);

Why is it not able to find the class? It both exists and implements `Parcelable`.

  [1]: http://developer.android.com/reference/android/os/Parcelable.html
  [2]: http://developer.android.com/reference/android/os/Parcel.html
  [3]: http://www.netmite.com/android/mydroid/frameworks/base/core/java/android/os/Parcel.java

Problem unmarshalling parcelables

I am looking for a _simple_ Json (de)serializer for Java that might work with GWT. I have googled a bit and found some solutions that either require annotate every member or define useless interfaces. Quite a boring. Why don&#39;t we have something really simple like

    class MyBean {
        ...
    }

    new GoodSerializer().makeString(new MyBean());
    new GoodSerializer().makeObject(&quot;{ ... }&quot;, MyBean.class)




Json &lt;-&gt; Java serialization that works with GWT

How do you convert System::String to std::string in C++ .NET?

C++ .NET convert System::String to std::string

**I tested a lot.** But I found no disadvantages of those 2!&lt;br&gt;
But see the accepted answer.
&lt;hr&gt;
I read [here][1] that calling `GetLastError` in managed code is unsafe because the Framework might internally &quot;overwrite&quot; the last error. I have never had any noticeable problems with `GetLastError` and it seems for me that the .NET Framework is smart enough not to overwrite it. Therefore I have a few questions on that topic:

 - in `[DllImport(&quot;kernel32.dll&quot;, SetLastError = true)]` does the `SetLastError` attribute make the Framework store the error code for the use of `Marshal.GetLastWin32Error()` ?
 - is there an example where plain `GetLastError` fails to give the correct result ?
 - do I **really HAVE** to use `Marshal.GetLastWin32Error()` ?
 - is this &quot;problem&quot; Framework version related ?
&lt;hr&gt;

    public class ForceFailure
    {
        [DllImport(&quot;kernel32.dll&quot;)]
        static extern uint GetLastError();
        [DllImport(&quot;kernel32.dll&quot;, SetLastError = true)]
        static extern bool SetVolumeLabel(string lpRootPathName, string lpVolumeName);

        public static void Main()
        {
            if (SetVolumeLabel(&quot;XYZ:\\&quot;, &quot;My Imaginary Drive &quot;))
                System.Console.WriteLine(&quot;It worked???&quot;);
            else
            {
                // the first last error check is fine here:
                System.Console.WriteLine(GetLastError());
                System.Console.WriteLine(Marshal.GetLastWin32Error());
            }
        }
    }
&lt;hr&gt;
**Producing errors:**

    if (SetVolumeLabel(&quot;XYZ:\\&quot;, &quot;My Imaginary Drive &quot;))
        Console.WriteLine(&quot;It worked???&quot;);
    else
    {
        // bad programming but ok GetlLastError is overwritten:
        Console.WriteLine(Marshal.GetLastWin32Error());
        try
        {
            using (new FileStream(&quot;sdsdafsdfsdfs sdsd &quot;, FileMode.Open)) { }
        }
        catch { }
        Console.WriteLine(GetLastError());
    }
&lt;hr&gt;

    if (SetVolumeLabel(&quot;XYZ:\\&quot;, &quot;My Imaginary Drive &quot;))
        Console.WriteLine(&quot;It worked???&quot;);
    else
    {
        // bad programming and Marshal.GetLastWin32Error() is overwritten as well:
        Console.WriteLine(GetLastError());
        try
        {
            using (new FileStream(&quot;sdsdafsdfsdfs sdsd &quot;, FileMode.Open)) { }
        }
        catch { }
        Console.WriteLine(Marshal.GetLastWin32Error());
    }
&lt;hr&gt;

    // turn off concurrent GC
    GC.Collect(); // doesn&#39;t effect any of the candidates

    Console.WriteLine(&quot; -&gt; &quot; + GetLastError());
    Console.WriteLine(&quot; -&gt; &quot; + GetLastError());
    Console.WriteLine(Marshal.GetLastWin32Error());
    Console.WriteLine(Marshal.GetLastWin32Error());
    // when you exchange them -&gt; same behaviour just turned around

I don&#39;t see any difference! Both behave the same except `Marshal.GetLastWin32Error` stores results from App-&gt;CLR-&gt;WinApi calls as well and `GetLastError` stores only results from App-&gt;WinApi calls.
&lt;hr&gt;
**Garbage Collection** seems not to call any WinApi functions overwriting the last error code

 - GetLastError is thread-safe. SetLastError stores an error code for each thread calling it.
 - since when would GC run in my threads ?

  [1]: http://blogs.msdn.com/b/adam_nathan/archive/2003/04/25/56643.aspx

WinApi - GetLastError vs. Marshal.GetLastWin32Error

I was marshaling and unmarshaling JSONs using golang and when I want to do it with number fields golang transforms it in floating point numbers instead of use long numbers, for example.

I have the following JSON:

    {
        &quot;id&quot;: 12423434, 
        &quot;Name&quot;: &quot;Fernando&quot;
    }

After `marshal` it to a map and `unmarshal` again to a json string I get:

    {
        &quot;id&quot;:1.2423434e+07,
        &quot;Name&quot;:&quot;Fernando&quot;
    }

As you can see the `&quot;id&quot;` field is in floating point notation. 

The code that I am using is the following:

    package main
    
    import (
    	&quot;encoding/json&quot;
    	&quot;fmt&quot;
    	&quot;os&quot;
    )
    
    func main() {
    
    	//Create the Json string
    	var b = []byte(`
    		{
    		&quot;id&quot;: 12423434, 
    		&quot;Name&quot;: &quot;Fernando&quot;
    		}
    	`)
    
    	//Marshal the json to a map
    	var f interface{}
        json.Unmarshal(b, &amp;f)
    	m := f.(map[string]interface{})
    	
    	//print the map
        fmt.Println(m)
    
    	//unmarshal the map to json
        result,_:= json.Marshal(m)
    
    	//print the json
    	os.Stdout.Write(result)
    
    }

It prints:

    map[id:1.2423434e+07 Name:Fernando]
    {&quot;Name&quot;:&quot;Fernando&quot;,&quot;id&quot;:1.2423434e+07}

It appears to be that the first `marshal` to the map generates the FP. How can I fix it to a long? 

This is the link to the program in the goland playground:
http://play.golang.org/p/RRJ6uU4Uw-


JSON unmarshaling with long numbers gives floating point number

Given a custom class `org.example.app.MyClass implements Parcelable`, I want to write a `List&lt;MyClass&gt;` to a Parcel. I did the marshalling with

     List&lt;MyClass&gt; myclassList = ...
     parcel.writeList(myclassList);

whenever I try to unmarshall the class with

     List&lt;MyClass&gt; myclassList = new ArrayList&lt;MyClass&gt;();
     parcel.readList(myclassList, null);

there is an `&quot;BadParcelableException: ClassNotFoundException when unmarshalling org.example.app.MyClass&quot;` exception.

What is wrong here? Why is the class not found?

&quot;BadParcelableException: ClassNotFoundException when unmarshalling &lt;myclass&gt;&quot; while using Parcel.read method that has a ClassLoader as argument

I want to pass an object from managed code to a WinApi function as `IntPtr`. It will pass this object back to my callback function in managed code as `IntPtr`. It&#39;s not a structure, it&#39;s an instance of a class.

**How do I convert `object` to `IntPtr` and back ?**

C# - How To Convert Object To IntPtr And Back?

I have struct

    type tySurvey struct {
    	Id     int64            `json:&quot;id,omitempty&quot;`
    	Name   string           `json:&quot;name,omitempty&quot;`
    }

I do `json.Marshal` write JSON bytes in HTML page. jQuery modifies `name` field in object and encodes object using jQueries `JSON.stringify` and jQuery posts string to Go handler.

`id` field encoded as string.

Sent: `{&quot;id&quot;:1}` Received: `{&quot;id&quot;:&quot;1&quot;}`

Problem is that `json.Unmarshal` fails to unmarshal that JSON because `id` is not integer anymore.

    json: cannot unmarshal string into Go value of type int64

What is best way to handle such data? I do not wish to manually convert every field. I wish to write compact, bug free code.

Quotes is not too bad. JavaScript does not work well with int64.

I would like to learn the easy way to unmarshal json with string values in int64 values.

All Marshalling Solutions on Gang of Coders

Total of 24 Marshalling Solutions