Data and Business Logic Development

Work with a simple HTTP Listener and avoid problems with BOM

Sabrina C. — Sun, 09 Oct 2011 19:49:47 GMT

We are implementing an internal service (internal means that it runs on an intranet) for one of our softwares that exchanges messages with my application clients when they run on the users machines. The data exchanged is sent as an XML class to an HTTP Listener.

It looked all simple and easy except that, when the XML class arrived to the Listener, the XML De-Serializer went nuts telling us the class was not correctly formatted.

After some checks to verify if we did something wrong (I always start from the principle that the probability I make a mess is higher than the one that compiler or libraries from third parties are wrong) and not finding nothing in the serialization and deserialization routines, sniffing the data arriving in the request, we discovered that the serialized data got 3 bytes preceding the <?xml which starts every xml data, in Hexadecimal EB BB BF, we didn’t understand what it was, and after a moment thinking to what could be wrong in our code to produce such problem, we made a search through the internet and learn something important (as always you never stop learning things…) Anyway, we discovered these three characters are a BOM (Byte order Mark) that is automatically added by the system serializing in UTF-8 encoding. Notepad, Notepad++ and other text editors/readers ignore it so you never notice it’s existence, but it is there. The problem in my service was that when deserializing from a string the three characters were not discarded so the Deserialize method gave an error telling that it found bad characters at the beginning of the class.

Is there a way to avoid the problem with BOM? Yes, it is one of the parameters of the XmlWriterSettings

XmlWriterSettings xstt = new XmlWriterSettings();

xstt.Encoding = Encoding.UTF8 : new UTF8Encoding(false);
using (XmlWriter writer = XmlWriter.Create(stream, xstt))
{
   ...
}

Using this option to serialize the class avoids the BOM and the deserialization problems.

Hoping to help someone else solving this problem faster

Working with XML part 2

Sabrina C. — Mon, 01 Nov 2010 09:04:25 GMT

What the system offers for free

As I explained in previous post, .NET is very XML friendly, so it gives us a few base functionalities to avoid us doing things already done, here we say it saves us from inventing hot water. To demostrate the basic functionalities I build a simple, fundamentally useless class that demonstrates us how the basic data types of .NET are all serializable.

using System;
using System.Text;

namespace DnwEnitities.Entities
{
    public class Serializzabile
    {

        public Serializzabile()
        {
            TheChar = 'A';
            TheByte = 10;
            TheBool = true;
            TheShort = 100;
            TheInt = 1000;
            TheLong = 1000000;
            TheFloat = 1234.7899f;
            TheDouble = 9800000.89600;
            TheDecimal = 766000000.654390001m;
            TheString = "The string is very nice and useful.";
            TheDate = DateTime.Now;
            TheGuid = Guid.NewGuid();
            TheEnum = SerializableEnum.ALot;
        }
    
        public char TheChar
        {
            get;
            set;
        }

        public byte TheByte
        {
            get;
            set;
        }

        public bool TheBool
        {
            get;
            set;
        }

        public short TheShort
        {
            get;
            set;
        }

        public int TheInt
        {
            get;
            set;
        }

        public long TheLong
        {
            get;
            set;
        }

        public float TheFloat
        {
            get;
            set;
        }

        public double TheDouble
        {
            get;
            set;
        }

        public decimal TheDecimal
        {
            get;
            set;
        }

        public string TheString
        {
            get;
            set;
        }

        public DateTime TheDate
        {
            get;
            set;
        }

        public Guid TheGuid
        {
            get;
            set;
        }

        public SerializableEnum TheEnum
        {
            get;
            set;
        }

        public static Serializzabile ReadXml(string pSerializedData, bool pIsXmlData)
        {
            Serializzabile retP = null;
            if (!pIsXmlData)
            {
                retP = (Serializzabile)SerializeHelper.DeserializeFromFile(
                   typeof(Serializzabile), pSerializedData);
            }
            else
            {
                retP = (Serializzabile)SerializeHelper.DeserializeFromString(
                   typeof(Serializzabile), pSerializedData);
            }
            return (retP);
        }

        public virtual void WriteXml(string pFileName)
        {
            SerializeHelper.SerializeToFile(pFileName, this, typeof(Serializzabile), false, string.Empty);
        }

        public virtual string WriteXml()
        {
            return (SerializeHelper.SerializeToString(this, false, string.Empty));
        }

        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendFormat("Char: {0}", this.TheChar);
            sb.AppendLine();
            sb.AppendFormat("Byte: {0}", this.TheByte);
            sb.AppendLine();
            sb.AppendFormat("Bool: {0}", this.TheBool);
            sb.AppendLine();
            sb.AppendFormat("Short: {0}", this.TheShort);
            sb.AppendLine();
            sb.AppendFormat("Int: {0}", this.TheInt);
            sb.AppendLine();
            sb.AppendFormat("Long: {0}", this.TheLong);
            sb.AppendLine();
            sb.AppendFormat("Float: {0}", this.TheFloat);
            sb.AppendLine();
            sb.AppendFormat("Double: {0}", this.TheDouble);
            sb.AppendLine();
            sb.AppendFormat("Decimal: {0}", this.TheDecimal);
            sb.AppendLine();
            sb.AppendFormat("String: {0}", this.TheString);
            sb.AppendLine();
            sb.AppendFormat("Date: {0}", this.TheDate);
            sb.AppendLine();
            sb.AppendFormat("Guid: {0}", this.TheGuid);
            sb.AppendLine();
            sb.AppendFormat("Enum: {0}", this.TheEnum);
            sb.AppendLine();
            return (sb.ToString());
        }

    }

    public enum SerializableEnum : int
    {
        None = 0,
        All,
        Some,
        ALot
    }
    
}

This class represents the most raw and simple entity, it contains some public properties, one for each of the base data in .NET, it contains the WriteXml and ReadXml methods, using our Helper to write and read in XML the content of the class and an override of the ToString method that helps us visualize the class contents. There is also a simple Enumeration, showing us that enumerable values are serialized automatically.

Instantiating a class of Serializzabile type, and calling its WriteXml method to write its content to a file, the content of the file is the
following:

<?xml version="1.0" encoding="utf-8"?>
<Serializzabile xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance 
     xmlns:xsd="http://www.w3.org/2001/XMLSchema">
    <TheChar>65</TheChar>
    <TheByte>10</TheByte>
    <TheBool>true</TheBool>
    <TheShort>100</TheShort>
    <TheInt>1000</TheInt>
    <TheLong>1000000</TheLong>
    <TheFloat>1234.78992</TheFloat>
    <TheDouble>9800000.896</TheDouble>
    <TheDecimal>766000000.654390001</TheDecimal>
    <TheString>The string is very nice and useful.</TheString>
    <TheDate>2010-11-01T09:26:13.331+01:00</TheDate>
    <TheGuid>3da90b04-ec02-4308-a177-fc6723ab8aa9</TheGuid>
    <TheEnum>ALot</TheEnum>
</Serializzabile>

Using the ReadXml to re-read the class, we will obtain an equivalent object. If we haven’t any particular requirement to satisfy in our programs, this is the simplest way to build a serializable entity.

Technorati Tag: XML,entities,serialization

Working with XML part 1

Sabrina C. — Sun, 31 Oct 2010 22:46:43 GMT

This is the first of a small series of posts dedicated to XML serialization, publishing the code I used for the last Workshop we did last month. I’ll start from the serialization Helper class, already discussed in the past, now revised for Framework 4.0.

To persist on a disk a C# (orVB) class, you need to create it with some simple tricks to make it serializable. Serialization is a word I’ve started to listen around 2003 at the first conferences on .NET I attended to. Maybe it’s self explanatory for an English mother tongue, but it wasn’t for me. I needed a while to understand that Serialization is the way to persist on mass storage the state of an object to be able to rebuild the same object with the exactly same state as the one we persisted on disk.

Entity classes are classes with no particular abilities, they are defined this way because they represent structured data, so entities are the classes representing a Data Model, it can be simple and persisted on a file, or complex, like a LinqToSql or EntityFramework model persisted on a database. Entities are the kind of class we will surely serialize someway.

In .NET, you can serialize data in 2 ways, binary serialization and XML serialization. All the base data types in .NET are serializable, so any class containing only this kind of data, can be directly serialized with no particular modification except it needs to implement a parameterless constructor.

What is automatically serialized by .NET in an object? The public properties. Why only these? I think it is because they represent the state of the object as it can be observed by who instantiated it, we can always modify the standard behaviour overriding the default serialization. In these articles we will however show only how to use the standard serialization and how to drive it how we desire just using a few simple functionalities given us by the framework itself.

SerializeHelper class

This class provides all serialization services for simple object and composite objects (collections or classes containing other classes). It uses the classes of the System.Xml and System.Xml.Serialization namespaces. Let’s see its methods.

BuildReader

        public static XmlTextReader BuildReader(string pXmlString)
        {
            NameTable nt = new NameTable();
            XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt);
            nsmgr.AddNamespace("bk", "urn:sample");

            XmlParserContext context = new XmlParserContext(null, nsmgr, null, XmlSpace.None);

            return (new XmlTextReader(pXmlString, XmlNodeType.Element, context));
        }

This first method, as it's name says, creates an XmlTextReader, that together with the correspondent XmlTextWriter are the base streams for reading and writing XML data. The method above has been designed to allow us to transform a string (such as a database field) in an Xml stream. The method generates a “fake” context to build the XmlTextReader to transform the string in a stream.

DeserializeFromString

        public static object DeserializeFromString(Type pTypeToDeserialize, string pXmlString)
        {
            object ret = null;
            using (XmlReader xr = BuildReader(pXmlString))
            {
                XmlSerializer serializer = new XmlSerializer(pTypeToDeserialize);
                ret = serializer.Deserialize(xr);
                xr.Close();
            }
            return (ret);
        }

        public static object DeserializeFromString(Type pTypeToDeserialize, 
               Type[] pExtraTypes, string pXmlString)
        {
            object ret = null;
            using (XmlReader xr = BuildReader(pXmlString))
            {
                XmlSerializer serializer = new XmlSerializer(pTypeToDeserialize, pExtraTypes);
                ret = serializer.Deserialize(xr);
                xr.Close();
            }
            return (ret);
        }

These two methods, one built for a class with only simple objects, another for a class with complex data types, use the previous method to create a stream that is then passed to the XmlSerializer class to get the object from the persisted string.

DeserializeFromFile

        public static object DeserializeFromFile(Type pTypeToDeserialize, string pPath)
        {
            object ret = null;
            using (XmlTextReader reader = new XmlTextReader(pPath))
            {
                // Occorre un'istanza della classe XmlSerializer
                XmlSerializer serializer = new XmlSerializer(pTypeToDeserialize);
                // e questo é tutto ciò che serve per leggere i dati dal formato XML
                ret = serializer.Deserialize(reader);
                reader.Close();
            }
            return (ret);
        }

        public static object DeserializeFromFile(Type pTypeToDeserialize, 
            Type[] pExtraTypes, string pPath)
        {
            object ret = null;
            using (XmlTextReader reader = new XmlTextReader(pPath))
            {
                // Occorre un'istanza della classe XmlSerializer
                XmlSerializer serializer = new XmlSerializer(pTypeToDeserialize, pExtraTypes);
                // e questo é tutto ciò che serve per leggere i dati dal formato XML
                ret = serializer.Deserialize(reader);
                reader.Close();
            }
            return (ret);
        }

The deserialization from a file is simpler, because XmlTextReader has a constructor that builds it from a file path. The two overloads of this method allow us to specify to the XmlSerializer the classes used if the objects involved are not simple classes. We will see it’s use when we will deserialize collections, but collections are not the only complex classes we will see.

SerializeToFile

        public static void SerializeToFile(string pPath, object pObjToSerialize, 
          Type pTypeToSerialize, bool pNoNamespaces, string pPrefix)
        {
            FileInfo fInfo = new FileInfo(pPath);
            if (!Directory.Exists(fInfo.DirectoryName))
            {
                Directory.CreateDirectory(fInfo.DirectoryName);
            }            
            using(XmlTextWriter writer = new XmlTextWriter(pPath, Encoding.UTF8))
            {
                // write a readable file
                writer.Formatting = Formatting.Indented;
                writer.Indentation = 4;

                // Occorre un'istanza della classe XmlSerializer
                XmlSerializer serializer = new XmlSerializer(pTypeToSerialize);
                XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
                string prefix = pPrefix != null ? pPrefix : string.Empty;
                if (pNoNamespaces)
                {
                    ns.Add(prefix, TXT_Namespace);
                }
                // e questo é tutto ciò che serve per persistere i dati
                serializer.Serialize(writer, pObjToSerialize, ns);
                writer.Close();
            }
        }

        public static void SerializeToFile(string pPath, object pObjToSerialize, 
            Type pTypeToSerialize, Type[] pExtraTypes, bool pNoNamespaces, string pPrefix)
        {
            FileInfo fInfo = new FileInfo(pPath);
            if (!Directory.Exists(fInfo.DirectoryName))
            {
                Directory.CreateDirectory(fInfo.DirectoryName);
            }            
            using(XmlTextWriter writer = new XmlTextWriter(pPath, Encoding.UTF8))
            {
                // write a readable file
                writer.Formatting = Formatting.Indented;
                writer.Indentation = 4;
                //writer.Settings.OutputMethod = XmlOutputMethod.
                // Occorre un'istanza della classe XmlSerializer
                XmlSerializer serializer = new XmlSerializer(pTypeToSerialize, pExtraTypes);
                XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
                string prefix = pPrefix != null ? pPrefix : string.Empty;
                if (pNoNamespaces)
                {
                    ns.Add(prefix, TXT_Namespace);
                }
                // e questo é tutto ciò che serve per persistere i dati
                serializer.Serialize(writer, pObjToSerialize, ns);
                writer.Close();
            }
        }

For the serialization, we made the two overloads with informations on the classes and we added a few parameters that allow us to format the classes, pNoNamespaces and pPrefix.

In the code we can see how, creating the XmlTextWriter we can decide the Encoding used for the generated string, our method uses UTF8 standard serialization but if we need something else we can use another encoding. We can also control the Xml File formatting both using the Formatting Property and some other properties to determine indentation and indentation character.

The use of XmlSerializerNamespaces allows us to avoid the verbose series of the namespaces inserted automatically in the first element of a serialized class:

Replacing this with:

Or, using the Nonamespace flag:

“killing” the namespaces is opportune to create neutral classes for data exchange between different companies and softwares, while if we want to be sure that our own classes are marked specifically to make them unique, we can add our namespace (usually it is the domain name of our website).

the pPrefix parameter has instead the purpouse to allow us to set a prefix on the name of our classes to obtain the following effect:

<dnw:Programmer xmlns:dnw="http://www.dotnetwork.it">

<dnw:Skills>

It allows us to specify in detail the use of our own objects without a full namespace attribute on each of them.

SerializeToString

        public static string SerializeToString(object pObjToSerialize, 
            Type[] pExtraTypes, bool pNoNamespaces, string pPrefix)
        {
            string ret = string.Empty;
            using (MemoryStream stream = new MemoryStream())
            {
                XmlSerializer serializer = new XmlSerializer(pObjToSerialize.GetType(), pExtraTypes);
                XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
                string prefix = pPrefix != null ? pPrefix : string.Empty;
                if (pNoNamespaces)
                {
                    ns.Add(prefix, TXT_Namespace);
                }
                serializer.Serialize(stream, pObjToSerialize, ns);
                ret = Encoding.UTF8.GetString(stream.ToArray());
                stream.Close();
            }
            return (ret);
        }

        public static string SerializeToString(object pObjToSerialize, bool pNoNamespaces, string pPrefix)
        {
            string ret = string.Empty;
            using (MemoryStream stream = new MemoryStream())
            {
                XmlSerializer serializer = new XmlSerializer(pObjToSerialize.GetType());
                XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
                string prefix = pPrefix != null ? pPrefix : string.Empty;
                if (pNoNamespaces)
                {
                    ns.Add(prefix, TXT_Namespace);
                }
                serializer.Serialize(stream, pObjToSerialize, ns);
                ret = Encoding.UTF8.GetString(stream.ToArray());
                stream.Close();
            }
            return (ret);
        }

The last method, with two overloads, allows us the Xml serialization of an object on a string instead of serializing it on a file stream. To be able to do so we need however a stream, we use the MemoryStream to avoid a file on disk, the Xml generation remain identical to the one that builds a file on disk.

Technorati Tag: C#,Xml,Serializzazione,Helper

Collection and predicates search elements without cycling

Sabrina C. — Fri, 13 Aug 2010 15:29:07 GMT

Among the most useful things when you work with collections, are Search methods, allowing us to find an element inside the collection using the value of one or more of his properties as a search criteria.

These methods can be implemented both as Indexer (a property) or a specific method. The second option is necessary because often there are more properties of the same data type used to search a collection and you can implement only one indexer with a certain signature.

Let’s work through some samples to see how to use predicates:

Our Entity class, named AnagraficaAzienda, exposes the following properties:

string DescrizioneRicerca //SearchDescription
string RagioneSociale //Company name
string PartitaIva //Vat Code
string Indirizzo //Address
string CAP //Zip code
string Citta //City
string PV //State or province
int IDTipo //Type
int IDAnagrafica //Identity

To create an Indexer to search through the SearchDescription we can use the following code:

public AnagraficaAzienda this[string pDescrizioneRicerca]
{
    get
    {
        return( Find(item=>item.DescrizioneRicerca==pDescrizioneRicerca);
    }
}

to create a method to get all elements that match a regular expression we can use the following code:

public List<AnagraficaAzienda> FindWithRegEx( string pRegEx )
{
    return (FindAll(items => Regex.Match(items.RagioneSociale, pRegEx).Success));
}

to create a method that returns the data using the Vat Code (PartitaIva) we can use the following code:

public AnagraficaAzienda FindXPartitaIva(string pPartitaIva)
{
    return( Find(item=>item.PartitaIva==pPartitaIva);
}

To create a multi dimensional indexer we can use the following code

public AnagraficaAzienda this[int pIDZona, int pIDAnagrafica]
{
    get
    {
        return( Find(item=>item.IDZona==pIDZona && item.IDAnagrafica==pIDAnagrafica);
    }
}

as you can see, a Predicate allows us to use any kind of binary expression to match the entity fields with the search criteria we want to use.

Tags: Collection, Predicate, Find, FindAll

How to create a Guid.Empty in SQL

Sabrina C. — Tue, 10 Aug 2010 20:53:20 GMT

Last friday my colleague Luca was “fighting” with a problem in managing null values and GUIDs. A Guid is a value type so it is not nullable. In my stored procedures when using parameters for filtering, I use the NULL value as the default value to ignore a filter parameter.

Changing the code of several classes to be able to change a Guid.Empty into a DbNull before passing it to a SELECT command was decisely not the best thing to do, so we searched a way to recreate a Guid.Empty value in SQL.

We were able to create the small snippet of SQL in the following function:

CREATE FUNCTION Guid_Empty()
RETURNS UniqueIdentifier
AS
BEGIN
RETURN cast(cast(0 as binary) as uniqueidentifier)
END
GO

After the creation of the above function and a simple table on my Paperinik Database, I was able to write the following query:

SELECT [ID]
      ,[Descrizione]
      ,[Prezzo]
      ,[Quantità]
      ,[Umi]
      ,IsNull(AltGuid, dbo.Guid_EMPTY()) AS Alt
  FROM [paperinik].[dbo].[TbRighe]

The query produces the following output:

I can use it also to build a query like the one below:

SELECT [ID]
      ,[Descrizione]
      ,[Prezzo]
      ,[Quantità]
      ,[Umi]
      ,IsNull(AltGuid, dbo.Guid_EMPTY()) AS Alt
  FROM [paperinik].[dbo].[TbRighe]
WHERE
IsNull(AltGuid, dbo.Guid_EMPTY()) = dbo.Guid_EMPTY()

That allows me to filter only the Guid Empty rows, or I can use the <> to find only the rows with a non Empty Guid. This way of writing the query, is giving me the possibility to use Guid.Empty in my Code as a SQLParameter value without the need to use a Nullable Guid or to implement complicated control expressions in my C# classes.

Technorati Tag: SQL,C#,Guid

Access the Deleted Rows of a Datatable

Sabrina C. — Mon, 09 Aug 2010 15:03:42 GMT

Today, I’m updating the Code Generator I’ve made in 2006 to build automatically the Data Provider classes for my applications. I’m passing my applications to Framework 4.0 and instead of a simple framework change, I’ve decided to make some cleaning in Old Common Libraries code and add some new features in the Data Classes.

One of the new features in my data classes, will be some events, raised when data operations complete, RowAdded and RowDeleted events are two of them. In both cases, it would probably be useful if you Handle the Event in your code, to have some informations on the Added Row or Deleted Row, so I decided to pass the whole DataRow as a property of the event argument.

Pass the Added row as an argument is very simple, I have the object in my method.

Pass the Deleted row is a little less simple. I’ve made a simple test project to find out how to get it, to be precise, the exact phrase is: How to get a copy of it.

The sample form is the following:

On the form there are 3 buttons – Carica = Load, Test Aggiunta = Test AddRow, Test cancellazione = Test Deletion. There is also a textbox, set as Multiline with vertical scrollbar.

The test code is the following:

        DataTable mDt;
        private const string FLD_ID = "ID";
        private const string FLD_Description = "Description";
        private const string FLD_Date = "Date";
        private const string FLD_Price = "Price";

        public Form1()
        {
            InitializeComponent();
            mDt = new DataTable("Tbtest");
            DataColumn col = new DataColumn(FLD_ID, typeof(int));
            col.AutoIncrement = true;
            col.AutoIncrementSeed = 1;
            col.AutoIncrementStep = 1;
            mDt.Columns.Add(col);
            col = new DataColumn(FLD_Description, typeof(string));
            mDt.Columns.Add(col);
            col = new DataColumn(FLD_Date, typeof(DateTime));
            mDt.Columns.Add(col);
            col = new DataColumn(FLD_Price, typeof(Decimal));
            mDt.Columns.Add(col);
        }

The initialization code, I build a Datatable on the Constructor code of the form.

        private void btnCarica_Click(object sender, EventArgs e)
        {
            mDt.Rows.Clear();

            DataRow row = mDt.NewRow();
            row[FLD_Description] = "Quaderno";
            row[FLD_Date] = DateTime.Now;
            row[FLD_Price] = 1.5;
            mDt.Rows.Add(row);

            row = mDt.NewRow();
            row[FLD_Description] = "Penna";
            row[FLD_Date] = DateTime.Now;
            row[FLD_Price] = 2.8;
            mDt.Rows.Add(row);

            row = mDt.NewRow();
            row[FLD_Description] = "Gomma";
            row[FLD_Date] = DateTime.Now;
            row[FLD_Price] = 0.7;
            mDt.Rows.Add(row);

            row = mDt.NewRow();
            row[FLD_Description] = "Matita";
            row[FLD_Date] = DateTime.Now;
            row[FLD_Price] = 1.1;
            mDt.Rows.Add(row);

            row = mDt.NewRow();
            row[FLD_Description] = "Block notes";
            row[FLD_Date] = DateTime.Now;
            row[FLD_Price] = 2.8;
            mDt.Rows.Add(row);

            row = mDt.NewRow();
            row[FLD_Description] = "Pennarelli 12 colori";
            row[FLD_Date] = DateTime.Now;
            row[FLD_Price] = 6.7;
            mDt.Rows.Add(row);

            mDt.AcceptChanges();

            Mostra();
        }

Here I build some rows, put them in the DataTable and call the Mostra method, wich shows the rows in the textbox.

        private void Mostra()
        {
            this.txtResult.Text = string.Empty;
            for( int i=0; i< mDt.Rows.Count;i++)
            {
                MostraRiga(mDt.Rows[i]);
            }
    
        }

        private void MostraRiga(DataRow pRow)
        {
            this.txtResult.Text += "ID: " + pRow[FLD_ID].ToString() + Environment.NewLine;
            this.txtResult.Text += "Description: " + pRow[FLD_Description].ToString() + Environment.NewLine;
            this.txtResult.Text += "Date: " + pRow[FLD_Date].ToString() + Environment.NewLine;
            this.txtResult.Text += "Price: " + pRow[FLD_Price].ToString() + Environment.NewLine;
            this.txtResult.Text += Environment.NewLine;
        }

This is the Mostra method and the MostraRiga Method, made to show the content of the table rows on the textbox.

        private void btnAdd_Click(object sender, EventArgs e)
        {

            DataRow row = mDt.NewRow();
            mDt.Rows.Add(row);
            row[FLD_Description] = string.Format("Nuova riga {0}", row[FLD_ID]);
            row[FLD_Date] = DateTime.Now;
            decimal pippo = Convert.ToDecimal(row[FLD_ID]);
            row[FLD_Price] = pippo*0.98m;

            mDt.AcceptChanges();

            MostraRiga(row);
        }

Here is the AddRow test, that simply builds a row, adds it to the table and then shows it on the textbox.

        private void btnDelete_Click(object sender, EventArgs e)
        {
            DataRow row = mDt.Rows[0];
            int id = Convert.ToInt32(row[FLD_ID]);
            row.Delete();
            string filter = string.Format("{0} = {1}", FLD_ID, id);
            DataView vi = new DataView(mDt, filter,"", DataViewRowState.Deleted);
            DataTable tt = vi.ToTable();
            mDt.AcceptChanges();
            MostraRiga(tt.Rows[0]);
        }

And finally the most important bit of code, the code that helps us to show the informations of the deleted row.
As you can see, the method simply deletes the first row of the DataTable, saving it’s ID.
After the deletion, to be able to get the whole row, I build a dataview that retrieves the row I’ve deleted and then uses the ToTable method of the DataView to put the data in a new Table. Then I give the Row to the MostraRiga (ShowRow) method and I can see its content on my textbox.

The ToTable passage is very important, because if you try to pass to the function something like:

MostraRiga(vi[0].Row);

Whichis perfectly legal with a non deleted row, you instead receive an Exception, because you cannot access deleted rows data.

Technorati Tag: C#,DataTable,DataView,Deleted Rows

Use of Rank function to extract a list of rows with the highest date

Sabrina C. — Wed, 07 Jul 2010 21:45:13 GMT

Today I had the problem to create a query to get the most recent price from a pricelists table. Every pricelist in the table can contain the same article any number of times with different startup dates. I made some search to find a way to obtain what i needed and I found the RANK function, it was used in a similar scenario. I publish this post as usual to remember how to use this function next time I need it and in the hope to help someone else solving similar problems.

The table:

CREATE TABLE [dbo].[TbPricelistsRg](
    [IDPriceListRg] [int] NOT NULL,
    [IDPriceList] [nvarchar](10) NOT NULL,
    [IDArticle] [nvarchar](32) NULL,
    [Price] [decimal](18, 5) NULL,
    [StartDate] [date] NULL,
 CONSTRAINT [PK_TbPriceListsRg] PRIMARY KEY CLUSTERED 
(
    [IDPriceListRg] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  
     = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]

Every row is linked to a PriceList through the IDPriceLIst field, we don’t need to use it for the example so it is omitted.

INSERT INTO [dbo].[TbPricelistsRg]
           ([IDPriceList]
           ,[IDArticle]
           ,[Price]
           ,[StartDate])
     VALUES
           ('CLD'
           ,'ABC'
           ,10
           ,CONVERT(date, '20080105', 112))
GO

INSERT INTO [dbo].[TbPricelistsRg]
           ([IDPriceList]
           ,[IDArticle]
           ,[Price]
           ,[StartDate])
     VALUES
           ('CLD'
           ,'OCQ'
           ,14
           ,CONVERT(date, '20080105', 112))
GO

INSERT INTO [dbo].[TbPricelistsRg]
           ([IDPriceList]
           ,[IDArticle]
           ,[Price]
           ,[StartDate])
     VALUES
           ('CLD'
           ,'FYS'
           ,21
           ,CONVERT(date, '20080105', 112))
GO

INSERT INTO [dbo].[TbPricelistsRg]
           ([IDPriceList]
           ,[IDArticle]
           ,[Price]
           ,[StartDate])
     VALUES
           ('CLD'
           ,'MUI'
           ,13
           ,CONVERT(date, '20080105', 112))
GO

INSERT INTO [dbo].[TbPricelistsRg]
           ([IDPriceList]
           ,[IDArticle]
           ,[Price]
           ,[StartDate])
     VALUES
           ('CLD'
           ,'SIO'
           ,42
           ,CONVERT(date, '20080105', 112))
GO

INSERT INTO [dbo].[TbPricelistsRg]
           ([IDPriceList]
           ,[IDArticle]
           ,[Price]
           ,[StartDate])
     VALUES
           ('CLD'
           ,'GOU'
           ,18
           ,CONVERT(date, '20080105', 112))
GO

INSERT INTO [dbo].[TbPricelistsRg]
           ([IDPriceList]
           ,[IDArticle]
           ,[Price]
           ,[StartDate])
     VALUES
           ('CLD'
           ,'HOU'
           ,20
           ,CONVERT(date, '20080105', 112))
GO

The previous script inserts some articles, we can repeat it changing the PriceLIst, the Dates and prices to be able to show how the query meets our needs.

SELECT [IDPriceListRg]
      ,[IDPriceList]
      ,[IDArticle]
      ,[Price]
      ,[StartDate]
      ,RANK() OVER (PARTITION BY IDPriceList, IDArticle ORDER BY StartDate DESC) DATERANK
  FROM [paperinik].[dbo].[TbPricelistsRg]

The RANK function, allows us to indicate one or more grouping fields on which calculate ranking, this is done using the PARTITION BY keywords, in our query we indicate the two fields on which ranking has to break. The ORDER BY keyword, instead indicates on which field we have to measure ranking. while the DESC keywords tells that we want to start from the most recent date..

This is the result of our query.

IDListinoRg	IDListino	IDArticolo	Prezzo	ValidoDal	DATERANK
107	CLD	ABC	1.000.000	24/10/2010	1
86	CLD	ABC	1.000.000	15/05/2010	2
65	CLD	ABC	1.000.000	08/01/2010	3
44	CLD	ABC	1.000.000	08/09/2009	4
23	CLD	ABC	1.000.000	16/04/2009	5
1	CLD	ABC	1.000.000	05/01/2008	6
2	CLD	ABC	1.000.000	05/01/2008	6
109	CLD	FYS	2.100.000	24/10/2010	1
88	CLD	FYS	2.100.000	15/05/2010	2
67	CLD	FYS	2.100.000	08/01/2010	3
46	CLD	FYS	2.100.000	08/09/2009	4
25	CLD	FYS	2.100.000	16/04/2009	5
4	CLD	FYS	2.100.000	05/01/2008	6
112	CLD	GOU	1.800.000	24/10/2010	1
91	CLD	GOU	1.800.000	15/05/2010	2
70	CLD	GOU	1.800.000	08/01/2010	3
49	CLD	GOU	1.800.000	08/09/2009	4
28	CLD	GOU	1.800.000	16/04/2009	5
7	CLD	GOU	1.800.000	05/01/2008	6
113	CLD	HOU	2.000.000	24/10/2010	1
92	CLD	HOU	2.000.000	15/05/2010	2
71	CLD	HOU	2.000.000	08/01/2010	3
50	CLD	HOU	2.000.000	08/09/2009	4
29	CLD	HOU	2.000.000	16/04/2009	5
8	CLD	HOU	2.000.000	05/01/2008	6

So to obtain the most recent prices, we need just to add a filter on DATERANK = 1, and to obtain the less recent price we just need to delete the DESC keyword and filter on rank 1.

Technorati Tag: SQL,RANK,DATE