How to | Software by Default

Archive for the 'How to' Category

C# How to: Encoding Bitmaps to Base64 strings

Article purpose

This article explores encoding Bitmap images to Base64 strings. Encoding is implemented by means of an extension method targeting the Bitmap class.

Sample source code

This article is accompanied by a sample source code Visual Studio project which is available for download here.

Images as Base64 strings

From Wikipedia:

Base64 is a group of similar encoding schemes that represent binary data in an ASCII string format by translating it into a radix-64 representation. The Base64 term originates from a specific MIME content transfer encoding.

Base64 encoding schemes are commonly used when there is a need to encode binary data that need to be stored and transferred over media that are designed to deal with textual data. This is to ensure that the data remain intact without modification during transport. Base64 is commonly used in a number of applications including email via MIME, and storing complex data in XML.

From the definition quoted above the need for base64 encoding becomes more clear. From MSDN documentation:

The base-64 digits in ascending order from zero are the uppercase characters "A" to "Z", the lowercase characters "a" to "z", the numerals "0" to "9", and the symbols "+" and "/". The valueless character, "=", is used for trailing padding.

Base64 encoding allows developers to expose binary data without potentially encountering conflicts in regards to the transfer medium. Base64 encoded binary data serves ideally when performing data transfer operations using platforms such as html, xml, email.

A common implementation of Base64 encoding can be found when transferring image data. This article details how to convert/encode a Bitmap object to a Base64 string.

Base64 Bitmap encoding implemented as an extension method

The code snippet listed below details the ToBase64String extension method targeting the Bitmap class.

public static string ToBase64String(this Bitmap bmp, ImageFormat imageFormat)
{
    string base64String = string.Empty;

 
    MemoryStream memoryStream = new MemoryStream();
    bmp.Save(memoryStream, imageFormat);

  
    memoryStream.Position = 0;
    byte[] byteBuffer = memoryStream.ToArray();

  
    memoryStream.Close();

  
    base64String = Convert.ToBase64String(byteBuffer);
    byteBuffer = null;

  
    return base64String;
}

The ToBase64String method writes the targeted Bitmap object’s pixel data to a MemoryStream object using the specified ImageFormat parameter. Next a byte array is extracted and passed to the method Convert.ToBase64String, which is responsible for implementing the Base64 encoding.

Creating an Image tag implementing a Base64 string

The sample source code in addition also defines an extension method to generate html image tags to display a Base64 string encoded image.

 public static string ToBase64ImageTag(this Bitmap bmp, ImageFormat imageFormat)
{
    string imgTag = string.Empty;
    string base64String = string.Empty;

 
    base64String = bmp.ToBase64String(imageFormat);

  
    imgTag = "<img src=\\"data:image/" + imageFormat.ToString() + ";base64,";
    imgTag += base64String + "\\" ";
    imgTag += "width=\\"" + bmp.Width.ToString() + "\\" ";
    imgTag += "height=\\"" + bmp.Height.ToString() + "\\" />";

 
    return imgTag;
}

The ToBase64ImageTag extension method invokes the ToBase64String extension method in order to retrieve encoded the data. The Html image tag has only to be slightly modified from the norm in order to accommodate Base64 encoded strings.

The implementation

The two extension methods are implemented using a console based application.

 static void Main(string[] args)
{
    StreamReader streamReader = new StreamReader("NavForward.png");
    Bitmap bmp = new Bitmap(streamReader.BaseStream);
    streamReader.Close();

 
    string base64ImageAndTag = bmp.ToBase64ImageTag(ImageFormat.Png);

  
    Console.WriteLine(base64ImageAndTag);

  
    Console.ReadKey();
}

C# How to: Deep copy objects using NetDataContractSerializer

Published February 22, 2013 C# , Code Samples , Extension Methods , Generics , How to , Microsoft , New Version , Opensource , Tip , XML , XML Serialization Leave a Comment
Tags: Binary serialization, C#, Code Sample, Deep Copy, deserialize to object, Extension Methods, Generics, How to, MemberwiseClone, NetDataContractSerializer, serialize to xml, Shallow Copy, Xml, Xml Deserialization, Xml Serialization

Article purpose

This article will illustrate how to create deep copies of an object by making use of the NetDataContractSerializer implemented in the form of an extension method with generic type support.

Sample source code

This article is accompanied by a sample source code Visual Studio project which is available for download here.

Shallow Copy and Deep Copy

When creating a copy of an object in memory, the type of copy can be described as either a shallow copy or a deep copy. The Object class defines the MemberwiseClone method, which performs a bit by bit copy of an object’s value type members. In the case of reference type members the MemberwiseClone method will create a copy of the reference, but not a copy of the Object being referenced. Creating a copy of an Object using the MemberwiseClone method will thus result in copies and the original Object still referencing the same member Object in memory when that Object is a reference type. The MemberwiseClone method performs a shallow copy when invoked.

A deep copy of an Object results in copies and the original Object not referencing the same reference type member Object in memory.

This article is a follow up article on: C# How to: Deep copy objects using Binary Serialization. When using Binary Serialization objects being serialized have to be decorated with any number of attributes which aid serialization and deserialization. An object’s definition has to at the very least specify the Serializable attribute, if not attempting serialization results in a runtime exception.

The advantage of implementing deep copy operations by making use of a NetDataContractSerializer can be argued around not having to specify serialization attributes. Although, as is the case with binary serialization, only objects that define a default/parameter less public constructor can be serialized without specifying any additional attributes.

Example custom data type

The code snippet listed below illustrates several user/custom defined data types. Notice the complete absence of any code attributes, as usually required for successful serialization/deserialization. Also pay attention to the private member variables, being an enum and user defined reference type defined towards the end of this snippet.

For the sake of convenience I overload the ToString() method, returning a string representation of an object’s member values.

public class CustomDataType 
{ 
     private CustomEnum enumMember = CustomEnum.EnumVal1; 
     private ExampleReferenceType referenceType = new ExampleReferenceType(); 

      
     public void RefreshReferenceType() 
     { 
         referenceType.Refresh(); 
     } 

 
     private int intMember = 0; 
     public int IntMember 
     { 
         get { return intMember; } 
         set { intMember = value; } 
     } 

 
     private string stringMember = String.Empty; 
     public string StringMember 
     { 
         get { return stringMember; } 
         set { stringMember = value; } 
     } 

 
     private DateTime dateTimeMember = DateTime.MinValue; 
     public DateTime DateTimeMember 
     { 
         get { return dateTimeMember; } 
         set { dateTimeMember = value; } 
     } 

 
     public override string ToString() 
     { 
         return "IntMember: " + IntMember + 
             ", DateTimeMember: " + DateTimeMember.ToString() + 
             ", StringMember: " + stringMember + ", EnumMember: " + 
             enumMember.ToString() + 
             ", ReferenceType: " + referenceType.ToString(); 
     } 

 
     public void SetEnumValue(CustomEnum enumValue) 
     { 
         enumMember = enumValue; 
     } 
} 

 
public class ExampleReferenceType 
{ 
     private DateTime createdDate = DateTime.Now; 

 
     public void Refresh() 
     { 
         createdDate = DateTime.Now; 
     }

 
     public override string ToString() 
     { 
         return createdDate.ToString("HH:mm:ss.fff"); 
     } 
} 

    
public enum CustomEnum 
{ 
     EnumVal1 = 2, 
     EnumVal2 = 4, 
     EnumVal3 = 8, 
     EnumVal4 = 16, 
}

The DeepCopy method – Implementation as an extension method with generic type support

Extension method architecture enables developers to create methods which, from a syntactic and implementation point of view appear to be part of an existing data type. Extension methods create the perception of being updates or additions, literarily extending a data type as the name implies. Extension methods do not require access to the source code of the particular types being extended, nor does the implementation thereof require recompilation of the referenced types.

This article illustrates a combined implementation of extension methods extending the functionality of generic types. The following code snippet provides the extension method definition.

public static class ExtObject 
{ 
    public static T DeepCopy<T>(this T objectToCopy) 
    {    
        MemoryStream memoryStream = new MemoryStream(); 

 
        NetDataContractSerializer netFormatter =
                       new NetDataContractSerializer(); 

  
        netFormatter.Serialize(memoryStream, objectToCopy); 

  
        memoryStream.Position = 0; 
        T returnValue = (T)netFormatter.Deserialize(memoryStream); 

  
        memoryStream.Close(); 
        memoryStream.Dispose(); 

  
        return returnValue; 
    } 
}

The DeepCopy method is defined as an extension method by virtue of being a static method of a static class and by specifying the this keyword in its parameter definition.

DeepCopy additionally defines the generic type <T> which determines the return value’s type and the type of the parameter objectToCopy.

The method body creates an instance of a MemoryStream object and an object instance of type NetDataContractSerializer. When the Serialize method is invoked the Xml representation of the objectToCopy parameter is written to the specified MemoryStream. In a similar fashion Deserialize is invoked next, reading the Xml representation from the specified MemoryStream. The object returned is cast to the same type as the object originally serialized.

Note: From MSDN documentation:

Serializes and deserializes an instance of a type into XML stream or document using the supplied .NET Framework types.

The NetDataContractSerializer differs from the DataContractSerializer in one important way: the NetDataContractSerializer includes CLR type information in the serialized XML, whereas the DataContractSerializer does not. Therefore, the NetDataContractSerializer can be used only if both the serializing and deserializing ends share the same CLR types.

In the scenario illustrated it can be considered safe to use NetDataContractSerializer since objects being serialized are only persisted to memory for a few milliseconds and then deserialized back to an object instance.

The implementation

The DeepCopy method illustrated above appears as a member method to the CustomDataType class created earlier.

static void Main(string[] args) 
{ 
    CustomDataType originalObject = new CustomDataType(); 
    originalObject.DateTimeMember = DateTime.Now; 
    originalObject.IntMember = 42; 
    originalObject.StringMember = "Some random string"; 

  
    CustomDataType deepCopyObject = originalObject.DeepCopy(); 
    deepCopyObject.DateTimeMember = DateTime.MinValue; 
    deepCopyObject.IntMember = 123; 
    deepCopyObject.StringMember = "Something else..."; 
    deepCopyObject.SetEnumValue(CustomEnum.EnumVal3); 
    deepCopyObject.RefreshReferenceType(); 

  
    Console.WriteLine("originalObject: "); 
    Console.WriteLine(originalObject.ToString()); 
    Console.WriteLine(); 

  
    Console.WriteLine("deepCopyObject: "); 
    Console.WriteLine(deepCopyObject.ToString()); 
    Console.WriteLine(); 

  
    Console.WriteLine("Press any key..."); 
    Console.ReadKey();   
}

The code snippet listed above is a console application which implements the DeepCopy extension method on objects of type CustomDataType. Modifying the member properties of the second object instance will not result in the first object instance properties being modified.

C# How to: Using Microsoft Kinect with Windows Forms

Published February 17, 2013 Augmented Reality , C# , Code Samples , Graphic Filters , Graphics , How to , Kinect for Windows , Microsoft , New Version , Opensource , Tip , Update 1 Comment
Tags: BitmapData, ColorImageFormat, ColorImageFrame, ColorImageFrame Bitmap, ColorStream.Enable, GDI, Kinect Bitmap, Kinect Bitmap.LockBits, Kinect ColorStream, Kinect for Windows, Kinect GDI, Kinect Marshal.Copy, Kinect RGB, Kinect Sensor, Kinect System.Drawing, Kinect Windows Forms, KinectSensor, OpenColorImageFrame, Windows Forms

Article purpose

This article illustrates a basic introductory level explanation of the steps required to interface with the Microsoft Kinect for Windows sensor using the Kinect for Windows Sdk implemented in a Windows Forms application.

Introduction

Most of the introduction level articles and code samples I’ve come across tend to be implemented as WPF or XNA based applications. Interfacing to the Microsoft Kinect for Windows sensor from Windows Forms based applications can be achieved fairly effortlessly. I find when wanting to create test applications a Windows Forms implementation can be developed quickly with relatively little hassle.

This article details creating a Windows Forms application which displays a live Video feed from the Kinect sensor’s Color camera whilst providing an option in specifying the resolution/frame rate.

Sample source code

This article is accompanied by sample source code in a Visual Studio project which is available for download here.

Sample Source Overview

The sample source code provided with this article consists of a Windows Form which host a PictureBox control used to display the incoming Video feed. It is possible that more than one Kinect sensor might be connected, the user can therefore select a sensor from a ComboBox. Possible resolutions/frame rates can also be configured via an additional ComboBox.

Available Kinect Sensors

The sample application implements the KinectSensor.KinectSensors property to retrieve a list of available Kinect sensor. The associated ComboBox will be populated with references to available sensors.

private void PopulateAvailableSensors()
{
    cmbSensors.Items.Clear();

  
    foreach (KinectSensor sensor in KinectSensor.KinectSensors)
    {
        cmbSensors.Items.Add(sensor.UniqueKinectId);
        cmbSensors.SelectedItem = sensor.UniqueKinectId;
    }
}

Initial setup: Form Constructor

In the Form constructor we define the available display modes by adding the relevant enumeration values to the associated ComboBox.

public  MainForm() 
{ 
   InitializeComponent(); 

 
   cmbDisplayMode.Items.Add(ColorImageFormat.RgbResolution640x480Fps30); 
   cmbDisplayMode.Items.Add(ColorImageFormat.RgbResolution1280x960Fps12); 
   cmbDisplayMode.SelectedIndex = 0; 

 
   PopulateAvailableSensors(); 
}

In this scenario we specify:

In the constructor the method PopulateAvailableSensors(), as described earlier, will be invoked after having specified available display modes.

Refreshing Available Sensors

Clicking the refresh button results in calling PopulateAvailableSensors(), which will re-determine available sensors and populate the associated ComboBox. Listed below is the click event handler subscribed to the Refresh button’s click event.

private void btnRefresh_Click(object sender, EventArgs e) 
{ 
    PopulateAvailableSensors(); 
}

Activating the Sensor

When clicking on the “Activate Sensor” button the sample code first attempts to deactivate the sensor currently in use. After ensuring that resources related to the current sensor have been released the application attempts to assign an instance of the KinectSensor member object based on user selection.

private  void  btnActivateSensor_Click(object  sender, EventArgs  e) 
{ 
    if (cmbSensors.SelectedIndex != -1) 
    { 
        DeActivateSensor(); 

  
        string sensorID = cmbSensors.SelectedItem.ToString(); 

  
        foreach (KinectSensor sensor in KinectSensor.KinectSensors) 
        { 
           if (sensor.UniqueKinectId == sensorID) 
            { 
                kinectSensor = sensor; 
                SetupSensorVideoInput(); 
            } 
        } 
    } 
}

Sensor Video setup

In the sample application we implement the Kinect sensor’s ColorStream camera. The Kinect sensor exposes an event which informs subscribed event handlers when a video frame is available for processing. The following code snippet shows the code implemented in setting up the video format.

private void SetupSensorVideoInput() 
{ 
    if (kinectSensor != null) 
    { 
         imageFormat = (ColorImageFormat)cmbDisplayMode.SelectedItem; 
         kinectSensor.ColorStream.Enable(imageFormat);     

  
         kinectSensor.ColorFrameReady += 
         new EventHandler<ColorImageFrameReadyEventArgs>(kinectSensor_ColorFrameReady); 

         
         kinectSensor.Start(); 
     } 
}

Processing Video Frames

The ColorFrameReady event informs subscribed event handlers whenever a Color frame becomes available for processing.

private void kinectSensor_ColorFrameReady(object  sender, ColorImageFrameReadyEventArgs  e) 
{ 
    ColorImageFrame colorFrame = e.OpenColorImageFrame();   

 
    if (colorFrame == null) 
    { 
         return; 
    }   

  
    Bitmap bitmapFrame = ColorImageFrameToBitmap(colorFrame); 
          
    picVideoDisplay.Image = bitmapFrame; 
}    

 
private static Bitmap ColorImageFrameToBitmap(ColorImageFrame colorFrame) 
{ 
    byte[] pixelBuffer = new  byte[colorFrame.PixelDataLength]; 
    colorFrame.CopyPixelDataTo(pixelBuffer);    

 
    Bitmap bitmapFrame = new Bitmap(colorFrame.Width, colorFrame.Height, 
        PixelFormat.Format32bppRgb); 

 
    BitmapData bitmapData = bitmapFrame.LockBits(new Rectangle(0, 0, 
                                     colorFrame.Width, colorFrame.Height), 
    ImageLockMode.WriteOnly, bitmapFrame.PixelFormat);   

  
    IntPtr intPointer = bitmapData.Scan0; 
    Marshal.Copy(pixelBuffer, 0, intPointer, colorFrame.PixelDataLength); 

           
    bitmapFrame.UnlockBits(bitmapData); 

  
    return  bitmapFrame; 
}

The event handler parameters provides access to a ColorImageFrame object. Before the video frame can be displayed the ColorImageFrame object first needs to be converted to a memory Bitmap, which can then be displayed by the Form’s PictureBox. Notice the ColorImageFrameToBitmap method, it functions by extracting image data from the ColorImageFrame as a byte array, then creates a new memory Bitmap and copies the byte array of image data.

Deactivating a sensor

Earlier when we activated the sensor we deactivated the active sensor. Listed below is the relevant code snippet.

private void DeActivateSensor() 
{ 
    if (kinectSensor != null) 
    { 
        kinectSensor.Stop(); 


        kinectSensor.ColorFrameReady -= 
        new EventHandler<ColorImageFrameReadyEventArgs>
        (kinectSensor_ColorFrameReady); 

 
        kinectSensor.Dispose(); 
    } 
}

C# How to: Generate a Web Service from WSDL

Published February 17, 2013 Code Samples , How to , Learn Everyday , Opensource , Tip , Web Services , XML , XML Serialization Leave a Comment
Tags: C#, client proxy, Compile WSDL, Generate Web Service, proxy code, service developers, Web method stubs, Web Service proxy, WSDL, Xml Deserialization, Xml Serialization

Article purpose

Web Service Definition Language (WSDL) is an Xml based schema that exactly details the custom data types and web service methods exposed by a web service. Developers usually generate web service client proxy code in order to call into web services. Since WSDL is an exact description of a web service it is also possible to generate code that represents the service in the form of web method stubs. This article illustrates how to generate a web service from WSDL.

Introduction

I’ve often found myself in a scenario where I have to interface with third parties via web services. It is often the case that third party service are proprietary, usually I find that I have very little control over the web services I’m required to interface to. Countless hours are wasted because of out dated test environments, missing/incorrect security certificates or even just trying to get hold of log files.

Time spent on development and testing can be significantly reduced in most cases if I had a local copy of a web service available to me. Having access to source code would be even more beneficial, being able to manipulate the data returned, testing timeouts etc. After surprisingly little effort I manage to develop a utility application capable of generating web method stubs and custom defined types in C# source code. The only required input in generating a web service is the WSDL of an existing web service.

Sample source code

This article is accompanied by sample source code in a Visual Studio project which is available for download here.

Input Web service WSDL

The sample source accompanying this article defines a very simplistic web service, consisting of one web method HelloWorld(). The source code is listed below:

 [WebService (Namespace = "http://softwarebydefault.com" )]

 [WebServiceBinding (ConformsTo = WsiProfiles.BasicProfile1_1)]

 [System.ComponentModel.ToolboxItem (false )]

 public class TestWebService : System.Web.Services.WebService

     [WebMethod ]

     public string  HelloWorld()

         return "Hello World";

The resulting WSDL is generated as illustrated by the following snippet:

<?xml version="1.0" encoding="utf-8"?>
<wsdl:definitions xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:tm="http://microsoft.com/wsdl/mime/textMatching/" xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/" xmlns:mime="http://schemas.xmlsoap.org/wsdl/mime/" xmlns:tns="http://softwarebydefault.com" xmlns:s="http://www.w3.org/2001/XMLSchema" xmlns:soap12="http://schemas.xmlsoap.org/wsdl/soap12/" xmlns:http="http://schemas.xmlsoap.org/wsdl/http/" targetNamespace="http://softwarebydefault.com" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/">
  <wsdl:types>
    <s:schema elementFormDefault="qualified" targetNamespace="http://softwarebydefault.com">
      <s:element name="HelloWorld">
        <s:complexType />
      </s:element>
      <s:element name="HelloWorldResponse">
        <s:complexType>
          <s:sequence>
            <s:element minOccurs="0" maxOccurs="1" name="HelloWorldResult" type="s:string" />
          </s:sequence>
        </s:complexType>
      </s:element>
    </s:schema>
  </wsdl:types>
  <wsdl:message name="HelloWorldSoapIn">
    <wsdl:part name="parameters" element="tns:HelloWorld" />
  </wsdl:message>
  <wsdl:message name="HelloWorldSoapOut">
    <wsdl:part name="parameters" element="tns:HelloWorldResponse" />
  </wsdl:message>
  <wsdl:portType name="TestWebServiceSoap">
    <wsdl:operation name="HelloWorld">
      <wsdl:input message="tns:HelloWorldSoapIn" />
      <wsdl:output message="tns:HelloWorldSoapOut" />
    </wsdl:operation>
  </wsdl:portType>
  <wsdl:binding name="TestWebServiceSoap" type="tns:TestWebServiceSoap">
    <soap:binding transport="http://schemas.xmlsoap.org/soap/http" />
    <wsdl:operation name="HelloWorld">
      <soap:operation soapAction="https://softwarebydefault.com/HelloWorld" style="document" />
      <wsdl:input>
        <soap:body use="literal" />
      </wsdl:input>
      <wsdl:output>
        <soap:body use="literal" />
      </wsdl:output>
    </wsdl:operation>
  </wsdl:binding>
  <wsdl:binding name="TestWebServiceSoap12" type="tns:TestWebServiceSoap">
    <soap12:binding transport="http://schemas.xmlsoap.org/soap/http" />
    <wsdl:operation name="HelloWorld">
      <soap12:operation soapAction="https://softwarebydefault.com/HelloWorld" style="document" />
      <wsdl:input>
        <soap12:body use="literal" />
      </wsdl:input>
      <wsdl:output>
        <soap12:body use="literal" />
      </wsdl:output>
    </wsdl:operation>
  </wsdl:binding>
  <wsdl:service name="TestWebService">
    <wsdl:port name="TestWebServiceSoap" binding="tns:TestWebServiceSoap">
      <soap:address location="http://localhost:6078/TestWS.asmx" />
    </wsdl:port>
    <wsdl:port name="TestWebServiceSoap12" binding="tns:TestWebServiceSoap12">
      <soap12:address location="http://localhost:6078/TestWS.asmx" />
    </wsdl:port>
  </wsdl:service>
</wsdl:definitions>

Generating the Web service from input WSDL

The crux of this article revolves around the Generate method defined in the associated sample source code. The method makes use of the ServiceDescription and ServiceDescriptionImporter classes to reference the WSDL generated earlier. The code defined by the Generate method is very similar to the code that would generate web service client proxy code. Make note of the Style property of the ServiceDescriptionImporter object being set to ServiceDescriptionImportStyle.Server. By setting the style to server we indicate that any code generated should reflect the server interface. Had the property being set to ServiceDescriptionImportStyle.Client web service client proxy code would be generated.

After importing the service descriptions as defined by the specified WSDL and if no errors occurred we generate C# source code based on the service descriptions imported. The resulting source code generated is then saved to the file system based on the file path passed as method parameter.

 public  static  void  Generate(string  wsdlPath, string  outputFilePath)

     if  (File.Exists(wsdlPath) == false )

         return;

     ServiceDescription  wsdlDescription = ServiceDescription .Read(wsdlPath);

     ServiceDescriptionImporter  wsdlImporter = new  ServiceDescriptionImporter ();

     wsdlImporter.ProtocolName = "Soap12";

     wsdlImporter.AddServiceDescription(wsdlDescription, null , null );

     wsdlImporter.Style = ServiceDescriptionImportStyle .Server;

     wsdlImporter.CodeGenerationOptions = System.Xml.Serialization.CodeGenerationOptions .GenerateProperties;

     CodeNamespace codeNamespace = new  CodeNamespace();

     CodeCompileUnit codeUnit = new  CodeCompileUnit();

     codeUnit.Namespaces.Add(codeNamespace);

     ServiceDescriptionImportWarnings importWarning = wsdlImporter.Import(codeNamespace, codeUnit);

     if  (importWarning == 0)

         StringBuilder stringBuilder = new StringBuilder();

         StringWriter stringWriter = new StringWriter(stringBuilder);

         CodeDomProvider codeProvider = CodeDomProvider.CreateProvider("CSharp");

         codeProvider.GenerateCodeFromCompileUnit(codeUnit, stringWriter, new CodeGeneratorOptions());

         stringWriter.Close();

         File.WriteAllText(outputFilePath, stringBuilder.ToString(), Encoding.UTF8);

     else

         Console.WriteLine(importWarning);

Notice the use of the CodeDomProvider class, creating an instance of this class allows us to generate source code. This class can also be used to compile source code to assemblies, in essence it allows developers access to a set of compilers accessible from code. As described by MSDN documentation:

A CodeDomProvider implementation typically provides code generation and/or code compilation interfaces for generating code and managing compilation for a single programming language. Several languages are supported by CodeDomProvider implementations that ship with the Windows Software Development Kit (SDK). These languages include C#, Visual Basic, C++, and JScript. Developers or compiler vendors can implement the ICodeGenerator and ICodeCompiler interfaces and provide a CodeDomProvider that extends CodeDOM support to other programming languages.

The Generated Code

The code generated comes in the form of abstract classes and methods. The snippet below illustrates the raw generated code:

 [System.CodeDom.Compiler.GeneratedCodeAttribute("WSDLToWebService" , "1.0.0.0" )]

 [System.Web.Services.WebServiceAttribute(Namespace="http://softwarebydefault.com" )]

 [System.Web.Services.WebServiceBindingAttribute(Name="TestWebServiceSoap12" , Namespace="http://softwarebydefault.com" )]

 public  abstract  partial  class  TestWebService  : System.Web.Services.WebService {

     [System.Web.Services.WebMethodAttribute()]

     [System.Web.Services.Protocols.SoapDocumentMethodAttribute("https://softwarebydefault.com/HelloWorld" ,

         RequestNamespace="http://softwarebydefault.com" , ResponseNamespace="http://softwarebydefault.com" ,

         Use=System.Web.Services.Description.SoapBindingUse.Literal,

         ParameterStyle=System.Web.Services.Protocols.SoapParameterStyle.Wrapped)]

     public  abstract  string  HelloWorld();

The code generated compiles without issue, but being declared abstract prevents the code from functioning as a web service implementation. I find the easiest method is to refactor the code instead of implementing inheritance. The snippet listed below represents the generated code refactored to reflect a web service implementation.

[System.CodeDom.Compiler.GeneratedCodeAttribute ("WSDLToWebService" , "1.0.0.0" )]

[System.Web.Services.WebServiceAttribute (Namespace = "http://softwarebydefault.com" )]

[System.Web.Services.WebServiceBindingAttribute (Name = "TestWebService" , Namespace = "http://softwarebydefault.com" )]

public  class  TestWebService  : System.Web.Services.WebService

     [System.Web.Services.WebMethodAttribute()]

     [System.Web.Services.Protocols.SoapDocumentMethodAttribute("https://softwarebydefault.com/HelloWorld" ,

     RequestNamespace = "http://softwarebydefault.com" , ResponseNamespace = "http://softwarebydefault.com" ,

     Use = System.Web.Services.Description.SoapBindingUse.Literal,

     ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)]

     public  string  HelloWorld()

         return  "Hello Generated World" ;

The TestWebService class and HelloWorld method is now no longer defined as abstract. In addition HelloWorld now defines a method body as required by not being an abstract method anymore.

About the Icons

I’ve written a number of articles exploring the topic of Image Colour filters. All of the Light bulb icon images featured in this article were generated from same source image, each having been manipulated by various colour filters. I made use of sample applications accompanying some of the articles I’ve published.

If you are interested in Image filters or would like to download the sample applications and source code please have a look at the following links to articles published on this site:

Examples of Image Filters

The original source image used to generate the icon images featured in this article has been licensed under the Creative Commons Attribution-Share Alike 3.0 Unported license and can be downloaded from Wikipedia.

C# How to: Deep copy objects using Binary Serialization

Published February 10, 2013 C# , Code Samples , Extension Methods , Generics , How to , Learn Everyday , Microsoft , Opensource , Tip , Update , XML , XML Serialization 1 Comment
Tags: Binary serialization, C#, Code Sample, Deep Copy, Extension Methods, generic type, Generics, MemberwiseClone, Open source, Reference copy, Serializable, Shallow Copy

Article purpose

This article will illustrate how to create deep copies of an object by making use of binary serialization implemented in the form of an extension method with generic type support.

Sample source code

This article is accompanied by a sample source code Visual Studio project which is available for download here.

Shallow Copy and Deep Copy

When creating a copy of an object in memory, the type of copy can be described as either a shallow copy or a deep copy. The Object class defines the MemberwiseClone method, which performs a bit by bit copy of an object’s value type members. In the case of reference type members the MemberwiseClone method will create a copy of the reference, but not a copy of the object being referenced. Creating a copy of an object using the MemberwiseClone method will thus result in copies and the original object still referencing the same member object in memory when that object is a reference type. The MemberwiseClone method performs a shallow copy when invoked.

A deep copy of an object results in copies and the original object not referencing the same reference type member object in memory.

Example custom data type

The sample source code provided with this article provides a user defined data type, the CustomDataType class of which the code snippet is listed below.

 [Serializable] 
public class CustomDataType  
{ 
   private int intMember = 0; 
   public int IntMember 
   { 
       get { return  intMember; } 
       set { intMember = value; } 
   } 

 
   private string stringMember = String.Empty; 
   public string StringMember 
   { 
       get { return stringMember; } 
       set { stringMember = value; } 
   } 

 
   private DateTime dateTimeMember = DateTime.MinValue;
   public DateTime DateTimeMember 
   { 
       get { return dateTimeMember; } 
       set { dateTimeMember = value; } 
   } 

 
   public override string ToString() 
   { 
       return "IntMember: " + IntMember + 
       ", DateTimeMember: " + DateTimeMember.ToString() + 
       ", StringMember: " + stringMember; 
   } 
}

Notice that the CustomDataType class definition is marked with the Serializable attribute. Objects of which the type definition is not marked with the Serializable attribute cannot be serialized. Trying to perform serialization on objects not marked as Serializable will result in an exception being thrown.

The DeepCopy method – Implementation as an extension method with generic type support

This article illustrates a combined implementation of extension methods extending the functionality of generic types. The following code snippet provides the extension method definition.

public staticclassExtObject  
{ 
    public static T DeepCopy<T>(this T objectToCopy) 
    { 
         MemoryStream memoryStream = new MemoryStream(); 
         BinaryFormatter binaryFormatter = new BinaryFormatter(); 
         binaryFormatter.Serialize(memoryStream, objectToCopy); 

  
         memoryStream.Position = 0; 
         T returnValue = (T)binaryFormatter.Deserialize(memoryStream); 

  
         memoryStream.Close(); 
         memoryStream.Dispose(); 

  
         return returnValue; 
    } 
}

The DeepCopy method is defined as an extension method by virtue of being a static method of a static class and by specifying the this keyword in its parameter definition.

DeepCopy additionally defines the generic type <T> which determines the return value’s type and the type of the parameter objectToCopy.

The method body creates an instance of a MemoryStream object and an object instance of type BinaryFormatter. When BinaryFormatter.Serialize is invoked the byte representation of the objectToCopy parameter is written to the specified MemoryStream. In a similar fashion BinaryFormatter.Deserialize is invoked next, reading the byte representation from the specified MemoryStream. The object returned is cast to the same type as the object originally serialized.

The implementation

The DeepCopy method illustrated above appears as a member method to the CustomDataType class created earlier.

 static void Main(string[] args) 
{ 
   CustomDataType originalObject = new CustomDataType(); 
   originalObject.DateTimeMember = DateTime.Now; 
   originalObject.IntMember = 42; 
   originalObject.StringMember = "Some random string"; 

  
   CustomDataType deepCopyObject = originalObject.DeepCopy(); 
   deepCopyObject.DateTimeMember = DateTime.MinValue; 
   deepCopyObject.IntMember = 123; 
   deepCopyObject.StringMember = "Something else..."; 

  
   Console.WriteLine("originalObject: " ); 
   Console.WriteLine(originalObject.ToString()); 
   Console.WriteLine(); 

  
   Console.WriteLine("deepCopyObject: " ); 
   Console.WriteLine(deepCopyObject.ToString()); 
   Console.WriteLine(); 

  
   Console.WriteLine("Press any key..." ); 
   Console.ReadKey();   
}

« Previous Page — Next Page »

Archive for the 'How to' Category

Article purpose

Sample source code

Images as Base64 strings

Base64 Bitmap encoding implemented as an extension method

Creating an Image tag implementing a Base64 string

The implementation

Rate this:

Share this:

Article purpose

Sample source code

Shallow Copy and Deep Copy

Example custom data type

The DeepCopy method – Implementation as an extension method with generic type support

The implementation

Rate this:

Share this:

Article purpose

Introduction

Sample source code

Sample Source Overview

Available Kinect Sensors

Initial setup: Form Constructor

Refreshing Available Sensors

Activating the Sensor

Sensor Video setup

Processing Video Frames

Deactivating a sensor

Rate this:

Share this:

Article purpose

Introduction

Sample source code

Input Web service WSDL

Generating the Web service from input WSDL

The Generated Code

About the Icons

Rate this:

Share this:

Article purpose

Sample source code

Shallow Copy and Deep Copy

Example custom data type

The DeepCopy method – Implementation as an extension method with generic type support

The implementation

Rate this:

Share this:

Dewald Esterhuizen

RSS Feed

Recent Posts

Blog Stats

Follow SoftwareByDefault via Email

Categories

Top Posts & Pages

Archives

C# How to Articles

SoftwareByDefault Online References

MSDN Articles

Categories

Tags