Export (0) Print
Expand All

SerializationInfo.GetInt32 Method

Retrieves a 32-bit signed integer value from the SerializationInfo.

[Visual Basic]
Public Function GetInt32( _
   ByVal name As String _
) As Integer
[C#]
public int GetInt32(
 string name
);
[C++]
public: int GetInt32(
 String* name
);
[JScript]
public function GetInt32(
   name : String
) : int;

Parameters

name
The name of the value to retrieve.

Return Value

The 32-bit signed integer associated with name.

Exceptions

Exception Type Condition
ArgumentNullException name is a null reference (Nothing in Visual Basic).
InvalidCastException The value associated with name cannot be converted to an 32-bit signed integer.
SerializationException An element with the specified name is not found in the current instance.

Remarks

If the value is a 32-bit signed integer, or can be converted to one, that value is returned; otherwise, an InvalidCastException is thrown. All conversions are done by the IFormatterConverter associated with this SerializationInfo.

Example

[Visual Basic] 
Imports System
Imports System.IO
Imports System.Collections
Imports System.Runtime.Serialization.Formatters.Binary
Imports System.Runtime.Serialization


' There should be only one instance of this type per AppDomain.
<Serializable()> Public NotInheritable Class Singleton
   Implements ISerializable

   ' This is the one instance of this type.
   Private Shared ReadOnly theOneObject As New Singleton

   ' Here are the instance fields.
   Public someString As String
   Public someNumber As Int32

   ' Private constructor allowing this type to construct the Singleton.
   Private Sub New()
      ' Do whatever is necessary to initialize the Singleton.
      someString = "This is a string field"
      someNumber = 123
   End Sub

   ' A method returning a reference to the Singleton.
   Public Shared Function GetSingleton() As Singleton
      Return theOneObject
   End Function

   ' A method called when serializing a Singleton.
   Private Sub GetObjectData(ByVal info As SerializationInfo, _
      ByVal context As StreamingContext) _
      Implements ISerializable.GetObjectData

      ' Instead of serializing this object, we will  
      ' serialize a SingletonSerializationHelp instead.
      info.SetType(GetType(SingletonSerializationHelper))
      ' No other values need to be added.
   End Sub

   ' Note: ISerializable's special constructor is not necessary 
   ' because it is never called.
End Class


<Serializable()> Friend NotInheritable Class SingletonSerializationHelper
   Implements IObjectReference
   ' This object has no fields (although it could).

   ' GetRealObject is called after this object is deserialized.
   Public Function GetRealObject(ByVal context As StreamingContext) As Object Implements IObjectReference.GetRealObject
      ' When deserialiing this object, return a reference to 
      ' the Singleton object instead.
      Return Singleton.GetSingleton()
   End Function
End Class


Class App
   <STAThread()> Shared Sub Main()
      Dim fs As New FileStream("DataFile.dat", FileMode.Create)

      Try
         ' Construct a BinaryFormatter and use it 
         ' to serialize the data to the stream.
         Dim formatter As New BinaryFormatter

         ' Create an array with multiple elements refering to 
         ' the one Singleton object.
         Dim a1() As Singleton = {Singleton.GetSingleton(), Singleton.GetSingleton()}

         ' This displays "True".
         Console.WriteLine("Do both array elements refer to the same object? " & _
            Object.ReferenceEquals(a1(0), a1(1)))

         ' Serialize the array elements.
         formatter.Serialize(fs, a1)

         ' Deserialize the array elements.
         fs.Position = 0
         Dim a2() As Singleton = DirectCast(formatter.Deserialize(fs), Singleton())

         ' This displays "True".
         Console.WriteLine("Do both array elements refer to the same object? " & _
            Object.ReferenceEquals(a2(0), a2(1)))

         ' This displays "True".
         Console.WriteLine("Do all array elements refer to the same object? " & _
            Object.ReferenceEquals(a1(0), a2(0)))
      Catch e As SerializationException
         Console.WriteLine("Failed to serialize. Reason: " & e.Message)
         Throw
      Finally
         fs.Close()
      End Try
   End Sub
End Class

[C#] 
using System;
using System.IO;
using System.Collections;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization;


// There should be only one instance of this type per AppDomain.
[Serializable]
public sealed class Singleton : ISerializable 
{
    // This is the one instance of this type.
    private static readonly Singleton theOneObject = new Singleton();

    // Here are the instance fields.
    public String someString;
    public Int32 someNumber;

    // Private constructor allowing this type to construct the Singleton.
    private Singleton() 
    { 
        // Do whatever is necessary to initialize the Singleton.
        someString = "This is a string field";
        someNumber = 123;
    }

    // A method returning a reference to the Singleton.
    public static Singleton GetSingleton() 
    { 
        return theOneObject; 
    }

    // A method called when serializing a Singleton.
    void ISerializable.GetObjectData(
        SerializationInfo info, StreamingContext context) 
    {
        // Instead of serializing this object, 
        // serialize a SingletonSerializationHelp instead.
        info.SetType(typeof(SingletonSerializationHelper));
        // No other values need to be added.
    }

    // Note: ISerializable's special constructor is not necessary 
    // because it is never called.
}


[Serializable]
internal sealed class SingletonSerializationHelper : IObjectReference 
{
    // This object has no fields (although it could).

    // GetRealObject is called after this object is deserialized.
    public Object GetRealObject(StreamingContext context) 
    {
        // When deserialiing this object, return a reference to 
        // the Singleton object instead.
        return Singleton.GetSingleton();
    }
}


class App 
{
    [STAThread]
    static void Main() 
    {
        FileStream fs = new FileStream("DataFile.dat", FileMode.Create);

        try 
        {
            // Construct a BinaryFormatter and use it 
            // to serialize the data to the stream.
            BinaryFormatter formatter = new BinaryFormatter();

            // Create an array with multiple elements refering to 
            // the one Singleton object.
            Singleton[] a1 = { Singleton.GetSingleton(), Singleton.GetSingleton() };

            // This displays "True".
            Console.WriteLine(
                "Do both array elements refer to the same object? " + 
                (a1[0] == a1[1]));     

            // Serialize the array elements.
            formatter.Serialize(fs, a1);

            // Deserialize the array elements.
            fs.Position = 0;
            Singleton[] a2 = (Singleton[]) formatter.Deserialize(fs);

            // This displays "True".
            Console.WriteLine("Do both array elements refer to the same object? " 
                + (a2[0] == a2[1])); 

            // This displays "True".
            Console.WriteLine("Do all array elements refer to the same object? " 
                + (a1[0] == a2[0]));
        }   
        catch (SerializationException e) 
        {
            Console.WriteLine("Failed to serialize. Reason: " + e.Message);
            throw;
        }
        finally 
        {
            fs.Close();
        }
    }
}

[C++] 
#using <mscorlib.dll>

using namespace System;
using namespace System::IO;
using namespace System::Collections;
using namespace System::Runtime::Serialization::Formatters::Binary;
using namespace System::Runtime::Serialization;


private __sealed __gc class SingletonSerializationHelper;

// There should be only one instance of this type per AppDomain.
[Serializable]
public __sealed __gc class Singleton : public ISerializable 
{
    // This is the one instance of this type.
private:
    static Singleton* theOneObject = new Singleton();

    // Here are the instance fields.
public:
    String* someString;
    Int32 someNumber;

    // Private constructor allowing this type to construct the singleton.
private:
    Singleton() 
    { 
        // Do whatever is necessary to initialize the singleton.
        someString = S"This is a String* field";
        someNumber = 123;
    }

    // A method returning a reference to the singleton.
public:
    static Singleton* GetSingleton() 
    { 
        return theOneObject; 
    }

    // A method called when serializing a Singleton.
    void GetObjectData(SerializationInfo* info, StreamingContext context) 
    {
        // Instead of serializing this Object*, we will  
        // serialize a SingletonSerializationHelp instead.
        info->SetType(__typeof(SingletonSerializationHelper));
        // No other values need to be added.
    }

    // NOTE: ISerializable*'s special constructor is NOT necessary 
    // because it's never called
};

[Serializable]
    private __sealed __gc class SingletonSerializationHelper : public IObjectReference 
    {
        // This Object* has no fields (although it could).
        // GetRealObject is called after this Object* is deserialized
    public:
        Object* GetRealObject(StreamingContext context) 
        {
            // When deserialiing this Object*, return a reference to 
            // the singleton Object* instead.
            return Singleton::GetSingleton();
        }
    };

[STAThread]
int main() 
{
    FileStream* fs = new FileStream(S"DataFile.dat", FileMode::Create);

    try 
    {
        // Construct a BinaryFormatter and use it 
        // to serialize the data to the stream.
        BinaryFormatter* formatter = new BinaryFormatter();

        // Create an array with multiple elements refering to 
        // the one Singleton Object*.
        Singleton* a1[] = { Singleton::GetSingleton(), Singleton::GetSingleton() };

        // This displays S"True".
        Console::WriteLine(S"Do both array elements refer to the same Object? {0}", __box((a1->Item[0] == a1->Item[1])));

        // Serialize the array elements.
        formatter->Serialize(fs, a1);

        // Deserialize the array elements.
        fs->Position = 0;
        Singleton* a2[] = (Singleton* __gc[]) formatter->Deserialize(fs);

        // This displays S"True".
        Console::WriteLine(S"Do both array elements refer to the same Object? {0}", __box((a2->Item[0] == a2->Item[1]))); 

        // This displays S"True".
        Console::WriteLine(S"Do all  array elements refer to the same Object? {0}", __box((a1->Item[0] == a2->Item[0])));
    } 
    catch (SerializationException* e) 
    {
        Console::WriteLine(S"Failed to serialize. Reason: {0}", e->Message);
        throw;
    }
    __finally 
    {
        fs->Close();
    }
    return 0;
}

[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button Language Filter in the upper-left corner of the page.

Requirements

Platforms: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 family

See Also

SerializationInfo Class | SerializationInfo Members | System.Runtime.Serialization Namespace

Show:
© 2015 Microsoft