As Good As It Gets: CF.Serialization, CF.Remoting, .NET Compact Framework Remoting, BinaryFormatter

CF.Serialization .NET Compact Framework BinaryFormatter		CF.Remoting.Client & CF.Remoting.Server .NET Compact Framework Remoting
	Source & binary level compatible with the full .NET Framework Lightning fast, ultra compact, low memory & CPU requirements BinaryFormatter, Serialization Surrogates, Dataset, DataTable serialization and more... Release (build 4.3.11.1229)		Source & binary level compatible with the full .NET Framework Lightning fast, ultra compact, low memory & CPU requirements Well-known, Singleton, TcpChannel with BinaryClientFormatterSink and BinaryServerFormatter Sink ChannelServices, LifetimeServices, Sinks, Proxy generators and more... Secure & Compression Channel Sinks Release (build 4.3.11.1229) Want to see a robot powered by CF.Remoting? Go ahead!

Now supports Microsoft .NET framework v4.x!

As Good As It Gets Compact Framework Remoting (CF.Remoting) is an SDK compatible with the desktop .NET Remoting infrastructure. CF.Remoting is designed for developing and deploying services on Windows CE/Mobile powered devices. It provides a runtime environment for your services, enabling you to consume other services as CLR types. Because our libraries are compatible with the full .NET Framework Remoting, you can leverage your current desktop development skill set when creating mobile applications in C# or Visual Basic. You can also reuse the same business logic and data access code that you use in your desktop application.

Although in theory you could build services without CF.Remoting, in practice building services is significantly easier with CF.Remoting. CF.Remoting is As Good As It Gets' implementation of a set of industry standards defining service interactions, type conversion, marshaling, and various protocols' management. Because of that, CF.Remoting provides interoperability between services on both mobile devices and desktop/servers.

The .NET Compact Framework does not support remoting, which makes As Good As It Gets CF.Remoting product one of the only frameworks for Windows-based handheld devices. We are closing the gap between .NET Compact Framework and desktop .NET Framework by bringing you the power of standard remoting right onto your device.

Developing for devices, using any tool, is still a specialty. It's clear that developers and customers need to get faster (and they are). The performance of the Web services available on the Compact Framework is … well, you know it. What would you say if your application worked 10 to 100 times faster if Web service layer was replaced with remoting? What would you say if the network bandwidth your device consumes was 20% of what you have to deal with the Web Services? CF.Remoting provides developers with the essential off-the-shelf plumbing required by almost any application, and as such, it greatly increases productivity. The release of CF.Remoting provides many useful facilities for developing services, proxy generators, service instance management, synchronous calls, call contexts, support for ObjRefs and security. CF.Remoting also has an elegant extensibility model that you can use to enrich the basic offering. In fact, CF.Remoting itself is written using this extensibility model. Most all of the CF.Remoting functionality is included in a single assembly called AsGoodAsItGets.Remoting.dll in the AsGoodAsItGets.System.Runtime.Remoting namespace.

Get the power of lightning fast TcpChannel (Client & Server) and HttpClientChannel (v4.0) with BinaryFormatter sink, secure and compress .NET remoting traffic with built-in Asymmetric Encryption Channel Sink and Compression Channel Sink, join the army of our customers in 30 countries worldwide today!

As Good As It Gets Compact Framework Serialization (CF.Serialization) is compatible with the desktop .NET BinaryFormatter, no smoke and mirrors. Yes, that is right – serialize your data on your server/desktop via standard BinaryFormatter implemented by Microsoft and process it on your device with As Good As It Gets CF.Serialization. We are the world's first to release the .NET Compact Framework serialization component library providing seamless integration with BinaryFormatter and other serialization classes available on full .NET Framework.

If you don't have the time to write your own custom serialization routines and would like to get a serialization facility for your C# or Visual Basic applications on the .NET Compact Framework, the As Good As It Gets' CF.Serialization is what you are looking for.

Say no more to performance and memory issues of the XmlSerializer, you can safely serialize/deserialize complex cyclic object graphs in compact binary form:

Save them in a disk file or a database and then restore it the next time the application is run.
Copy them to the system's clipboard and then paste into the same or other application.
Clone and set aside as a backup while a user manipulates the main set of objects.
Send them over the network to a process running on another machine.

Besides being 100% compatible with full .NET Framework BinaryFormatter the CF.Serialization also supports serialization surrogates for the following popular classes/successors of:

DataSet
DataTable
DBNull
Exception.
Generic Dictionary<TKey, TValue> / Dictionary(Of TKey, TValue).
Generic LinkedList<T> / LinkedList(Of T).
Hashtable
NameObjectCollectionBase.
Type.

Our formatters are about twice faster in serialization/deserialization of the DataSets on Compact Framework and resulting files are about thrice smaller than DataSet's XML serialization file.

The CF.Serialization has been written entirely in managed code, specifically targeted within the constraints of a mobile platform. It is simple to use and has been designed with data migration in mind.

Because our library is compatible with full .NET Framework BinaryFormatter, you can leverage your current desktop development skill set when creating mobile applications in C# or Visual Basic. You can also reuse the same business logic and data access code that you use in your desktop application. This makes an application faster to develop and lowers your maintenance cost. Please take a look at the following C# code snippet demonstrating 100% source code level compatibility, notice just a single change you will ever need to make:

using System;
using System.IO;
using System.Diagnostics;

#if PocketPC || WindowsCE
using AsGoodAsItGets.System.Runtime.Serialization;
using AsGoodAsItGets.System.Runtime.Serialization.Formatters.Binary;
#else
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
#endif

namespace Samples
{
    class Program
    {
        [Serializable]
        class Car
        {
            private string make;

public string Make
            {
                get { return make; }
                set { make = value; }
            }
        }

static void Main(string[] args)
        {
            Serialize();
            Deserialize();
        }

static void Serialize()
        {
            Car car = new Car();
            car.Make = "Honda";
            using (FileStream stream = new FileStream("Car.dat", FileMode.Create)) {
                BinaryFormatter formatter = new BinaryFormatter();
                try {
                    formatter.Serialize(stream, car);
                } catch (SerializationException e) {
                    Debug.WriteLine("Failed to serialize: " + e.Message);
                    throw;
                }
            }
        }

static void Deserialize()
        {
            using (FileStream stream = new FileStream("Car.dat", FileMode.Open)) {
                BinaryFormatter formatter = new BinaryFormatter();
                try {
                    // you can use generics version of Deserialize<T> method
                    // in addition to typical call with cast: car = (Car)formatter.Deserialize(...).
                    Car car = formatter.Deserialize<Car>(stream);
                    Debug.WriteLine(string.Format("Car.Make: {0}", car.Make));
                } catch (SerializationException e) {
                    Debug.WriteLine("Failed to deserialize: " + e.Message);
                    throw;
                }
            }
        }
    }
}

Learn more...