See Sharp Gears

Basic KSOAP Android Tutorial

noreply@blogger.com (Unknown) — Thu, 25 Nov 2010 10:02:00 +0000

This is a basic KSOAP Android tutorial - here I will show you how to get started with KSOAP on Android. As you may know, we often want to access Web services via hand-held devices, and most likely you will run into trouble parsing the WSDL and the SOAP messages. Since I come from a .NET background, once I started developing on Android, I realized how much work has been Visual Studio doing for me.

That thought took me to search for a framework or library to help me consume Web Services with Android. I ran into KSOAP2, which seemed like a good library, but unfortunately, very badly documented for most scenarios, like passing or returning complex objects, working with arrays of objects or even working with dates.

All of this I needed to find out by myself and this is why I decided to write this tutorial. So, let's begin.

Getting Started with KSOAP on Android

First things first, so you should now go ahead and download the KSOAP library from ~~Sourceforge~~ Google code (*UPDATE* thanks Freddy):
http://code.google.com/p/ksoap2-android/downloads/detail?name=ksoap2-android-assembly-2.4-jar-with-dependencies.jar&can=2&q=

Then copy and paste the KSOAP library in the folder where your Android project will reside. Open Eclipse, start a new Android Project, right-click on the project's name and choose Properties, like this:

The next thing you need to do is to Add the KSOAP .JAR into the Android Project:

Go ahead an press Add JARs... button. Then navigate to the folder where your KSOAP library is and select it. Once you have this done, you are ready to start working with your Web Service library.

Simple Web Service Calls with KSOAP

First, let's take a look at our web service call in Visual Studio:

[WebService(Namespace = "http://vladozver.org/")]
public class SimpleWebServices : System.Web.Services.WebService
{
      [WebMethod]
      public int GetSumOfTwoInts(int Operand1, int Operand2 )
      {
         return Operand1 + Operand2;
      }
}

The service is deployed on my local machine which is on the address: 192.168.1.3. Pay attention on the ending "/" in the Namespace.

Now, KSOAP finally.

KSOAP relies on a basic object called SoapObject. For this SoapObject, there are 3 variables that are important:
The Web Service Namespace
The Web Service Method Name
The Web Service URL

There is another extra variable which is important and is called SOAP_ACTION, but that is basically a concatenation of the Namespace and Method name:

SOAP_ACTION = NAMESPACE + METHOD_NAME;

For now we will create 3 strings for the respective variables:

String NAMESPACE = "http://vladozver.org/";
        String METHOD_NAME = "GetSumOfTwoInts";
        String SOAP_ACTION = "http://vladozver.org/GetSumOfTwoInts";
        String URL = "http://192.168.1.3/VipEvents/Services/BasicServices.asmx";

Then we will create the SoapObject:

SoapObject Request = new SoapObject(NAMESPACE, METHOD_NAME);

Parameters in KSOAP are passed via PropertyInfo class instances, so we will create some of those:

PropertyInfo pi = new PropertyInfo();
        pi.setName("Operand1");
        pi.setValue(2);
        pi.setType(int.class);
        Request.addProperty(pi);

        PropertyInfo pi2 = new PropertyInfo();
        pi2.setName("Operand2");
        pi2.setValue(5);
        pi2.setType(int.class);
        Request.addProperty(pi2);

Then we will create another important KSOAP object, and that is Soap Envelope:

SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(SoapEnvelope.VER11);
        envelope.dotNet = true;
        envelope.setOutputSoapObject(Request);

Because our Web Service is .NET based, we need to set the .dotNet property to true.
Next step is to create a Transport object:

AndroidHttpTransport androidHttpTransport = new AndroidHttpTransport(URL);

Lastly, we need to invoke the web service and obtain the result:

try
            {
                androidHttpTransport.call(SOAP_ACTION, envelope);
                SoapObject response = (SoapObject)envelope.getResponse();
                int result =  Integer.parseInt(response.getProperty(0).toString());
            }
            catch(Exception e)
            {
                e.printStackTrace();
            }

That is basically it! I hope you will find this tutorial helpful, as I see that many people are looking for a simple Getting started tutorial on KSOAP Android. For more advanced usage of KSOAP, refer to my other posts on this topic.

Implementing KSOAP Marshal Interface

noreply@blogger.com (Unknown) — Thu, 11 Nov 2010 07:37:00 +0000

Another poorly documented spot in KSOAP: marshaling arguments. In KSOAP, you need to implement an interface called Marshal so that the XML parser would know how to serialize and deserialize objects you are trying to pass through the web service.

Strangely enough, object types like "double" and "Date" need to be manually marshaled! This is why I decided my code examples to show how to marshal dates and doubles. So here it goes:

package Marshals;

import java.io.IOException;

import org.ksoap2.serialization.Marshal;
import org.ksoap2.serialization.PropertyInfo;
import org.ksoap2.serialization.SoapSerializationEnvelope;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import org.xmlpull.v1.XmlSerializer;
/**
* 
* @author Vladimir
* Used to marshal Doubles - crucial to serialization for SOAP
*/
public class MarshalDouble implements Marshal 
{


    public Object readInstance(XmlPullParser parser, String namespace, String name, 
            PropertyInfo expected) throws IOException, XmlPullParserException {
        
        return Double.parseDouble(parser.nextText());
    }


    public void register(SoapSerializationEnvelope cm) {
         cm.addMapping(cm.xsd, "double", Double.class, this);
        
    }


    public void writeInstance(XmlSerializer writer, Object obj) throws IOException {
           writer.text(obj.toString());
        }
    
}

As you can see, the code here is so trivial that I am honestly surprised why it does not come out of the box like it does for ints.
The next example shows how to Marhsal Dates with KSOAP:

package Marshals;

import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.kobjects.isodate.IsoDate;
import org.ksoap2.serialization.Marshal;
import org.ksoap2.serialization.PropertyInfo;
import org.ksoap2.serialization.SoapSerializationEnvelope;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import org.xmlpull.v1.XmlSerializer;

/**
 * 
 * @author Vladimir
 * Used to marshal Dates - crucial to serialization for SOAP
 */
public class MarshalDate implements Marshal
{

        public Object readInstance(XmlPullParser parser, String namespace, String name, 
                PropertyInfo expected) throws IOException, XmlPullParserException {
            
            return IsoDate.stringToDate(parser.nextText(), IsoDate.DATE_TIME);
            
            
        }


        public void register(SoapSerializationEnvelope cm) {
             cm.addMapping(cm.xsd, "DateTime", Date.class, this);
            
        }


        public void writeInstance(XmlSerializer writer, Object obj) throws IOException {
             writer.text(IsoDate.dateToString((Date) obj, IsoDate.DATE_TIME));
            }
    
}

As you probably assume, in order to tell KSOAP how to use the marshaling, you need to use the register() method in the following manner:

String MethodName = "GetEventById";
SoapObject request = GetSoapObject(MethodName);
AddProperty(request, Event);
SoapSerializationEnvelope envelope = GetEnvelope(request);
        
envelope.addMapping(NAMESPACE, "Event",Event.getClass());

MarshalDate md = new MarshalDate();
md.register(envelope);
       
SoapObject response =  MakeCall(URL,envelope,NAMESPACE,MethodName);

Basically that is all you need to get started with KSOAP marshaling.

Returning Array of Primitive Types with KSOAP

noreply@blogger.com (Unknown) — Thu, 04 Nov 2010 15:14:00 +0000

KSOAP until recently had an issue with returning an array of primitive types. With the new patch the issue is solved. If you haven't downloaded the newest version of
KSOAP available on GitHub, you can use the following snippet:

SoapObject request = new SoapObject(NAMESPACE, METHOD_NAME);
            SoapSerializationEnvelope envelope =
            new SoapSerializationEnvelope(SoapEnvelope.VER11);
            //envelope.dotNet = true;
            envelope.setOutputSoapObject(request);
            AndroidHttpTransport androidHttpTransport = new AndroidHttpTransport(URL);
        androidHttpTransport.call(SOAP_ACTION, envelope);

                KvmSerializable ks = (KvmSerializable)envelope.bodyIn;
                for(int i=0;i<ks.getPropertyCount();i++)
                {
                   ks.getProperty(i); //if complex type is present then you can cast this to SoapObject and if primitive type is returned you can use toString() to get actuall value.
                }

This code was written by nebe.daredevil

If anyone else is having trouble to return array of primitive types with KSOAP, might consider the issue thread on Google Code

I hope the agony with KSOAP is near an end with this.

Web Service That Returns An Array of Objects With KSOAP

noreply@blogger.com (Unknown) — Tue, 26 Oct 2010 09:18:00 +0000

In my previous post, I wrote about an example of passing complex objects with KSOAP. In this post, I will write about returning arrays of objects with KSOAP.
If you want to know how to write a method that returns an array of complex objects, look at this code:

public static Category[] GetAllCategories()
    {
        String MethodName = "GetAllCategories";
        SoapObject response = InvokeMethod(URL,MethodName);
        return RetrieveFromSoap(response);
        
    }

Where the function InvokeMethod is :

public static SoapObject InvokeMethod(String URL,String MethodName)
    {
        SoapObject request = GetSoapObject(MethodName);
        SoapSerializationEnvelope envelope = GetEnvelope(request);
        return  MakeCall(URL,envelope,NAMESPACE,MethodName);
    }

GetSoapObject() and GetEnvelope() are:

public static SoapObject GetSoapObject(String MethodName)
    {
        return new SoapObject(NAMESPACE,MethodName);
    }
    public static SoapSerializationEnvelope GetEnvelope(SoapObject Soap)
    {
        SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(SoapEnvelope.VER11);
        envelope.dotNet = true;
        envelope.setOutputSoapObject(Soap);
        return envelope;
    }

MakeCall() is :

/**
     * 
     * @param URL - The complete URL where the web service resides 
     * @param Envelope - The envelope to be passed
     * @param NAMESPACE - The web method namespace
     * @param METHOD_NAME - The method name
     * @return - SoapObject containing the resultset
     */
    public static SoapObject MakeCall(String URL, SoapSerializationEnvelope Envelope, String NAMESPACE, String METHOD_NAME)
    {
        AndroidHttpTransport androidHttpTransport = new AndroidHttpTransport(URL);
         try
            {
                androidHttpTransport.call(NAMESPACE + METHOD_NAME, Envelope);
                SoapObject response = (SoapObject)Envelope.getResponse();
                return response;
            }
         catch(Exception e)
         {
             e.printStackTrace();
             
         }
         return null;
    }

The most important part for retrieving the actual array of objects (in this case Category objects) is the following:

/**
     * 
     * @param soap - represents the entering Soap object
     * @return returns the list of categories extracted from the response
     */
    public static Category[] RetrieveFromSoap(SoapObject soap)
    {
        Category[] categories = new Category[soap.getPropertyCount()];
        for (int i = 0; i < categories.length; i++) {
            SoapObject pii = (SoapObject)soap.getProperty(i);
            Category category = new Category();
            category.CategoryId = Integer.parseInt(pii.getProperty(0).toString());
            category.Name = pii.getProperty(1).toString();
            category.Description = pii.getProperty(2).toString();
            categories[i] = category;
        }
        return categories;
    }

NOTE: Do not use VECTOR class type provided by KSOAP! It does not work.

I really copy-pasted this from Eclipse, but hope it helps. Please write if you need more help. I hope I saved you at least some nerves.

All the best.

KSoap Android Web Service Tutorial With Sample Code

noreply@blogger.com (Unknown) — Sun, 24 Oct 2010 23:05:00 +0000

A few months ago I was engaged into working with Android and I wanted to make an application that will communicate with the server via .NET SOAP web services, but I soon found out that I will need a library to do the "donkey work for me". Unfortunately, what Visual Studio was doing for me behind the scenes when importing WSDL document, was not present in Android. That means that, I would either parse the WSDL XML myself, or use an external library. After little search, I came up to KSOAP, which looked like a promising library. But soon I got into lot of trouble to make it work.
Partly because there was no complete tutorial with the WHOLE sample WORKING code for passing complex objects as parameters and/or arrays as return values (read this post for returning arrays of objects with KSOAP ), I spent many hours debugging exceptions which were filled with nulls and poor documentation in first place.

Therefore I decided to publish the code I managed to make it work, so many lives will be saved :-) hopefully. I almost forgot about the idea of publishing my code, but today I got some e-mails from some of the Google groups where I was begging for help when I was developing the Android application. So, tortured developer souls, a complete working code for working with the KSOAP library for Android:

Scenario:
We will assume that we want to write a web service that retrieves the details about a given Category by its Id. So, in .NET, the service signature would be:

[Web Method]
public Category GetCategoryById(Category C);

The class that we want to work with has 3 properties: CategoryId, Name and Description. But in order to use it with KSOAP, we need to implement the KvmSerializable interface (Code below is in Java):

package CommonObjects;

import java.util.Hashtable;
import org.ksoap2.serialization.KvmSerializable;
import org.ksoap2.serialization.PropertyInfo;

/**
 * 
 * @author Vladimir
 * Represents the Category object. KvmSerializable interface needs to be 
 * implemented for performing serialization.
 */
public class Category implements KvmSerializable
{
    public int CategoryId;
    public String Name;
    public String Description;
    
    public Category(){}
    

    public Category(int categoryId, String name, String description) {
        
        CategoryId = categoryId;
        Name = name;
        Description = description;
    }


    public Object getProperty(int arg0) {
        
        switch(arg0)
        {
        case 0:
            return CategoryId;
        case 1:
            return Name;
        case 2:
            return Description;
        }
        
        return null;
    }

    public int getPropertyCount() {
        return 3;
    }

    public void getPropertyInfo(int index, Hashtable arg1, PropertyInfo info) {
        switch(index)
        {
        case 0:
            info.type = PropertyInfo.INTEGER_CLASS;
            info.name = "CategoryId";
            break;
        case 1:
            info.type = PropertyInfo.STRING_CLASS;
            info.name = "Name";
            break;
        case 2:
            info.type = PropertyInfo.STRING_CLASS;
            info.name = "Description";
            break;
        default:break;
        }
    }

    public void setProperty(int index, Object value) {
        switch(index)
        {
        case 0:
            CategoryId = Integer.parseInt(value.toString());
            break;
        case 1:
            Name = value.toString();
            break;
        case 2:
            Description = value.toString();
            break;
        default:
            break;
        }
    }
}

All methods in this class are members of the KvmSerializable Interface, and are used to tell KSOAPhow to map the properties, read them and write them.

Now, the actual web service call:

public void WebServiceCallExample()
    {
        String NAMESPACE = "http://vladozver.org/";
        String METHOD_NAME = "GetCategoryById";
        String SOAP_ACTION = "http://vladozver.org/GetCategoryById";
        String URL = "http://192.168.1.3/VipEvents/Services/CategoryServices.asmx";
        
        SoapObject Request = new SoapObject(NAMESPACE, METHOD_NAME);
        
        /*
         * Create Category with Id to be passed as an argument
         * 
         * */
        Category C = new Category();
        C.CategoryId = 1;
        
        /*
         * Set the category to be the argument of the web service method
         * 
         * */
        PropertyInfo pi = new PropertyInfo();
        pi.setName("C");
        pi.setValue(C);
        pi.setType(C.getClass());
        Request.addProperty(pi);
        
        /*
         * Set the web service envelope
         * 
         * */
        SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(SoapEnvelope.VER11);
        envelope.dotNet = true;
        envelope.setOutputSoapObject(Request);
        
        envelope.addMapping(NAMESPACE, "Category",new Category().getClass());
        AndroidHttpTransport androidHttpTransport = new AndroidHttpTransport(URL);
        /*
         * Call the web service and retrieve result ... how luvly <3
         * 
         * */
        try
        {
            androidHttpTransport.call(SOAP_ACTION, envelope);
            SoapObject response = (SoapObject)envelope.getResponse();
            C.CategoryId =  Integer.parseInt(response.getProperty(0).toString());
            C.Name =  response.getProperty(1).toString();
            C.Description = (String) response.getProperty(2).toString();
            TextView tv = (TextView)findViewById(R.id.TextView01);
            tv.setText("CategoryId: " +C.CategoryId + " Name: " + C.Name + " Description " + C.Description);
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }

In order to use this code, make sure that you replace the first three variables in this method with your own. NOTE: The SOAP_ACTION could actually be computed as NAMESPACE + METHOD_NAME

In the lines about the property info, I show how to actually pass a Category class complex object to KSOAP.

PropertyInfo pi = new PropertyInfo();
        pi.setName("Category");
        pi.setValue(C);
        pi.setType(C.getClass());
        Request.addProperty(pi);

Regarding the return type, if your web method returns a complex object (such as ours), you need to tell KSOAP how to handle the response. That is done with the following code:

envelope.addMapping(NAMESPACE, "Category",new Category().getClass());

This part of the code is the actual retrieval of the response:

androidHttpTransport.call(SOAP_ACTION, envelope);
            SoapObject response = (SoapObject)envelope.getResponse();
            C.CategoryId =  Integer.parseInt(response.getProperty(0).toString());
            C.Name =  response.getProperty(1).toString();
            C.Description = (String) response.getProperty(2).toString();

For further reading, see my post about returning an array of complex objects with KSOAP

CsharpGears: New class for Dynamic Discovery of Stored Procedure Parameters

noreply@blogger.com (Unknown) — Fri, 13 Nov 2009 15:10:00 +0000

Yesterday I wrote a new class in the CSharpGears Framework. It is called ParameterExtractor and it's purpose is to discover the parameters of a given stored procedure and retrieve them in a collection. This class utilizes the method DeriveParameters in order to discover the parameters of the procedure and therefore, it can be only used with SQL Server unfortunately, but since SQL Server is quitte often a choice for database solution, this class might come in handy. The class also has caching capabilities, which can help saving performance since DeriveParameters method causes a roundtrip to the database, and you certainly don't want to have two accesses to the database for each query. Because of that, it uses static caching and keeps the list of parameters in a collection for further reuse. I have to admit that I am not certain about the thread safety of this operation, it is possible that a lock statement is required as a critical region.

My intention is to combine the ParameterExtractor and integrate it with my N-tier architecture, so that it will help me automate the parameter adding process from my business objects to the stored procedures. The framework already supports the reverse process, namely to map the datareader's columns into a list of business objects ( you can read my post about Object relational mapping if you are interested). I hope that soon my project architecture will contain clean, separated code which is also easy to write, due to the generics of C#.

However, one should be aware of the limitations of this class, it only works with SQL Server, and of course, it needs more memory to keep the stored procedure parameters, but its greatest adventage is that it is possible to write a code that will examine a business object and it will decide alone which attributes are needed to be mapped with which parameters - AUTOMATICALLY :).

"I am thinking that I am lazy..." - David Byrne

CsharpGears is Free and Open Source Framework

noreply@blogger.com (Unknown) — Fri, 25 Sep 2009 08:21:00 +0000

I use this opportunity to emphasize the fact that the CsharpGears Framework is absolutely Free and Open source, meaning anyone who wants can download the framework and use it for free, or even make changes in the code, but he/she can't claim he/she invented it.

Recently a reader told me he wanted to use my framework but he was interested in making changes in the source code, and then I noticed that I havent put the full version available for download, so I did that immediately.

And anyone who has some kind of trouble using the CsharpGears framework, may feel free to contact me, I will be happy to help. If anyone has a constructive suggestion or wish for next releases, post it as a suggestion.

"There is nothing like a dream to create the future" - Victor Hugo

C# RSS Builder : How to Build Really Simple Syndications

noreply@blogger.com (Unknown) — Fri, 18 Sep 2009 09:25:00 +0000

RSS has become quite popular recently, and from developer's point of view, it's a quite common requirement to implement. So I have decided to make an object-oriented approach and write a few classes that might come in handy. You can see the source code below, it is quite simple and straightforward. One note to those who haven't read my previous posts: The retrieval from the database is made by another set of classes called DatabaseEntities. These classes allow me to directly bind C# classes with SQL table columns and return lists of business objects instead of DataTables.

Back to the RSS feed, there are a few things you need to do: first you need RSS items, as by the standard of the RSS XML tags. Then you need to create a logo of the RSS feed. This is optional, but it is a nice way to offer your readers visual connection to your brand. You will also need a Stream object where the feed should be output. It could be any type of stream. For the purposes of this example, I am using a FileStream, but for a real scenario (ASP.NET) you would need to use the Response's output stream. Take a look at the code, and please tell me if it is REALLY SIMPLE :)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using RssBuilderLibrary;
using System.IO;
using DataBaseClassLibrary;
using System.Data;
namespace RssBuilderLibraryClient
{
class Program
{
static void Main(string[] args)
{
    /* Retrieve the latest products from the database as RSS items */
    string ConnectionString = "...";
    GenericDbEntity<RssItem> dbEntity = new GenericDbEntity<RssItem>("GetLatestProducts", 
ConnectionString);
    List<RssItem> latestProducts = (List<RssItem>) dbEntity.Select();
    
    /* Create an image logo in the RSS feed */
    RssImage imageLogo = new RssImage();
    imageLogo.Description = "This is a description";
    imageLogo.Title = "This is a title";
    imageLogo.Url = "http://example.com/image.jpg";
    imageLogo.Link = "http://mysite.com";

    /* Create a stream where the feed should be output - it could be any type of stream */
    FileStream fileStream = File.Create("rssfeed.xml");

    /* Create a RSS channel */
    RssChannel rss = new RssChannel(fileStream, imageLogo);

    /* Add all RSS items in the channel */
    foreach(IRssItem rssItem in latestProducts)
    {
        rss.AddRssItem(rssItem);
    }

    /* Publish the RSS feed to the output stream */
    rss.Publish();
}
}
}

C# Logger when Handling Exceptions

noreply@blogger.com (Unknown) — Tue, 15 Sep 2009 11:30:00 +0000

Having the Logger configured as in the previous post, it is very easy to use it to log exceptions directly. The ILogger interface provides a method called AppendException() which takes a reference of an Exception object, which will log the stack trace, the message and the targetted site of the exception that was thrown. If you are familiar with my previous post, you can use this class from the CsharpGears framework to log your exceptions out-of-the-box. For instance, in ASP.NET web applications, you could use this logger to trace all the exceptions in the global.asax file when handling the event OnApplicationError or anytime an exception occurs and then redirect the user to a custom error page.

Here is the minimum amount of code to set all that up:

/* Set up configuration for the logger */
            string DbProvider = "System.Data.SqlClient";
            string ConnectionString = "...";

            /* Create the logger */
            ILogger Logger = new DbLogger(DbProvider,ConnectionString);
            Configuration.LogLevel = LogLevel.ERROR;

            try
            {
                /* Generate an exception */
                int generates_exception = 1 / 0;
            }
            catch (Exception ex)
            {
                Logger.AppendException(ex);
            }
            /* Retrieve the messages from today */
            List<LogMessage> TodaysLogContent = Logger.ReadLogByDate(DateTime.Now);

            /* Print the log messages from today */
            foreach (LogMessage message in TodaysLogContent)
            {
                Console.WriteLine(message.Message + " " + message.UserName + " " + message.Date + "\n");
            }

Logging Exceptions in ASP.NET websites

protected void Application_Error(object sender, EventArgs e)
            {
                Exception ex = Server.GetLastError();
                string DbProvider = "System.Data.SqlClient";
                string ConnectionString = "...";

                /* Create the logger */
                ILogger Logger = new DbLogger(DbProvider, ConnectionString);
                Configuration.LogLevel = LogLevel.ERROR;
                Logger.AppendException(ex);
                // Clear the error and maybe redirect to some other page...
                Server.ClearError();
            }

You can see that all you need is a few lines of C# code and an object-oriented approach to your log messages is ready to be used. I really find it useful, would appreciate to tell me what do you think about it.

Creating C# Logger with CsharpGears

noreply@blogger.com (Unknown) — Thu, 10 Sep 2009 17:50:00 +0000

The Need of Logger for C#

Loggers come in handy when one wishes to trace the execution of his program. These pieces of code make life much easier when it comes to maintaining the application code error free. That is because with logging capabilities, the developer is able to track every time an unusual event occurs. Then it will be easy to determine where the code needs more attention, whether it includes refactoring, bugs or something else.

There are loggers for C#, they are not something new. But what they often lack, is known as ease-of-use. Here could fall Log4Net and other classes that could be found accross the Web. Often, developer needs a simple logger, some code that will get the job done when an exception is thrown.

Therefore I have decided to write flexible C# classes that will still be extremely simple to use, flexible by design, and will give the developer control of the log level.(Log levels are an important aspect of the loggers, as they give the power to control which events will enter the log, and which will be left out.

The Database Logger in C#
The Logger classes in the CsharpGears Framework are organized in the following way:

There exists a class named LoggerBase which is abstract and it also implements the ILogger interface. From it DbLogger class is derived, and that is the main class we are going to use. There are also SqlServerDbLoggerProvider class which configures the DbLogger so that it creates the needed tables and stored procedures in the database. These logger classes communicate with LogMessages. There is a generic LogMessage

from which other LogMessages are derived. For each log level, there exists an appropriate message.

So, let's show an example of the usage of the the C# logger.

/* Set up configuration for the logger */
string DbProvider = "System.Data.SqlClient";
            string ConnectionString = "...";

            /* Create the logger */
            ILogger Logger = new DbLogger(DbProvider,ConnectionString);
            Configuration.LogLevel = LogLevel.ERROR;
            /* Create log messages */
            ILogMessage Message = new LogMessage("Message Content: Error", "SYSTEM",
LogLevel.INFO);
            ILogMessage InfoMessage = new InfoLogMessage("Info log message", "SYSTEM");
            ILogMessage ErrorMessage = new ErrorLogMessage("Fatal error", "SYSTEM");
            ILogMessage AllMessage = new AllLogMessage("All log message", "SYSTEM");

            /* Append the messages */
            Logger.Append(Message);
            Logger.Append(InfoMessage);
            Logger.Append(ErrorMessage);
            Logger.Append(AllMessage);

            /* Retrieve all messages from the log */
            List<LogMessage> LogContent = Logger.ReadLog();

            /* Retrieve the messages from today */
            List<LogMessage> TodaysLogContent = Logger.ReadLogByDate(DateTime.Now);

            /* Print the log messages from today */
            foreach (LogMessage message in TodaysLogContent) 
            {
                Console.WriteLine(message.Message + " " + message.UserName + " "
+ message.Date + "\n");
            }

As you can see, you only need to configure the logger for the database provider and the connection string - and you are ready to go. When you want to append a message, you only need to create the appropriate message object - you can either use the interface notation, or create the message type directly, by creating a log message of the specific type. Then you need to invoke the Append() method. For retrieval of the messages from the logger, you need to invoke the method ReadLog(), or you can read the messages from today. (In the future version, I will add an opportunity to read according to the log level). And then, you will get a generic C# list of Log messages. In case you were wondering, this utilizes the DatabaseEntity classes, discussed in my previous post about database access with the CsharpGears framework.
If you have any questions about using this logger, feel free to ask. As you can see, it is very simple to use, and it abstracts most of the annoying things when developing logger classes in C#.

Writing Data Access Layer (DAL) and Business Access Layer (BAL) with CsharpGears Framework

noreply@blogger.com (Unknown) — Mon, 31 Aug 2009 16:19:00 +0000

Today I am going to show you how to write Data Access Layer (DAL) and Business Access Layer (BAL) using the CsharpGears Framework.

One of the most accepted approaches of the today's application architecture is the 3-tier architecture, or it's general version n-tier architecture. The idea is to separate the logic of the application in separate layers, each of which will be able to communicate in a standardized way with another layer. Most often, the tier that is responsible for displaying the data is called the presentation layer, which is capable of invoking the layer that holds all the business logic - namely the business layer. The business layer, however can either be invoked by the presentation layer and return the results of the execution to it. In certain situations, the business layer will need to access some amount of data in order to perform all the calculations. In that case, the business layer invokes the third layer - data layer. The data layer is responsible for retrieving the sets of data from some source - be it a database or xml file or web service - it can be literally anything.

Benefits of the three-tier architecture

Having the application separated in separate tiers (note: tier is synonym for layer) , brings a lot of advantages, among which are:

The application is divided in pieces that whose independence is brought to maximum, meaning that people can simultenously work on different layer, leading to cutting the development costs in both aspects of time and money.
Transparency. Each layer brings transparency for the other layers - this means that each layer minds it's own business, and when it needs help, it simply invokes other layers to help out. The good thing is, nobody interferes in the lives of the others. Moreover, the transparency brings flexibility, such as - the business layer does not care where the data layer gets the data from, its only concern is to get data. The presentation layer does not know nor cares who the data layer is, but it also does not know the details of what the business rules are; instead, the presentation layer only cares to display the results properly so that the end user sees what she needs to see.

What is the Data Access Layer (DAL)?

Well, I have mentioned the data layer is the layer that cares about the data, but it might be essentially observed as the Data Storage Layer, with or without capabilities to format the data. The raw data retrieval is usually accomplished by means of using SQL stored procedures, SQL ad-hoc queries, XPath expressions etc. But the thing is, the retrieved data is not always well formatted to align with the benefits of the Object-oriented Programming. In the case of SQL, (the more common I guess), although the data is retrieved as tables, sometimes it is not sufficient. A developer would still need to map that data to objects in the application. Having all this considered, one can define DAL as the part of the Data Layer that cares for mapping the retrieved rows into business classes (in C#, for instance). Please note that even if the DAL is often written in .NET, it still belongs to the Data Layer, do not directly assume that the Database represents the whole Data Layer.

What is Business Access Layer (BAL)?

BAL can be observed as an encapsulation of the business logic so that it keeps the transparency to the presentation layer. The part of the business layer that is responsible for invoking the business layer from upper layers - namely the presentation layer is called Business Access Layer. The BAL always returns objects to the presentation layer that it finds them suitable for displaying. BAL represents the encapsulation of the business layer.

Standardizing the Communication between Layers: Common Objects

Wouldn't it be nice if all the tiers communicated in the same fashion ? Of course, the more standardized the communication, the less effort to develop the application, because of the subtle error prevention the standardized communication. Even in practice, people have come to the conclusion that they must have a convention so that they can share ideas and thoughts: that is how protocols were invented. So the main idea here is to write a set of C# classes which will define the communication core between the layers. Those classes will contain no logic inside them, they will be more like OO placeholders for the data. Taking this approach, it becomes obvious that the only way the presentation layer invokes the business layer with some parameters is to construct common objects, fill them with data and send them to the business layer. The business layer, based on what kind of object received, decides to change it, return it, or invoke the data layer. The communication between the data layer and the business layer is also within the common objects domain - that is, the business tier must construct common objects that both the business tier and the data tier understand and send them to it. Once the data layer gets the common objects as parameters, it talks to the persistant medium and returns - a set of common objects to the business layer. The DAL should be well written to handle this transformation from raw data to sets of common objects. The BAL also will return as a result a set of common objects. With this approach in mind, it becomes very easy to develop applications because the code will contain less errors, it maintains its extensibility, new developers could jump in to the project with less effort etc.

Implementing DAL and BAL with CsharpGears Framework

Have you been following me up to now ? So far, so good. Now lets see how will everything that we said work in practice:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DevGears.DataBase;
using System.Data;
using DataLayer.Properties;
using System.Configuration;

namespace DataLayer
{
    public abstract class DataLayerBase
    {
        private IDataBase dbEntity;
        private string connectionString;

        protected IDataBase DbEntity
        {
            get { return dbEntity; }
            set { dbEntity = value; }
        }

        protected string ConnectionString
        {
            get { return connectionString; }
            set { connectionString = value; }
        }

        public DataLayerBase() 
        {
            connectionString = Settings.Default.connectionString;        
        }

        protected IDataBase CreateDbEntity(string StoredProcedure) 
        {
            return new DataBaseEntity(StoredProcedure, connectionString);
        }

        protected abstract void AddParameters();
        public abstract void Execute();

        protected void AddCommandParameter(string Name, object Value, DbType Type)
        {
            dbEntity.AddCommandParameter(Name, Value, Type);
        }
        protected void IntAddCommandParameter(string Name, object Value)
        {
            AddCommandParameter(Name, Value, DbType.Int32);
        }
        protected void StringAddCommandParameter(string Name, object Value)
        {
            AddCommandParameter(Name, Value, DbType.String);
        }
        protected void BoolAddCommandParameter(string Name, object Value)
        {
            AddCommandParameter(Name, Value, DbType.Boolean);
        }
        protected void DecimalAddCommandParameter(string Name, object Value)
        {
            AddCommandParameter(Name, Value, DbType.Decimal);
        }
        protected void DoubleAddCommandParameter(string Name, object Value)
        {
            AddCommandParameter(Name, Value, DbType.Double);
        }
        protected void DateTimeAddCommandParameter(string Name, object Value)
        {
            AddCommandParameter(Name, Value, DbType.DateTime);
        }
        protected void DateAddCommandParameter(string Name, object Value)
        {
            AddCommandParameter(Name, Value, DbType.Date);
        }
        protected void ByteAddCommandParameter(string Name, object Value)
        {
            AddCommandParameter(Name, Value, DbType.Byte);
        }
        protected void LongAddCommandParameter(string Name, object Value)
        {
            AddCommandParameter(Name, Value, DbType.Int64);
        }

    }
}

In order to maintain the flexibility of changing the names of the stored procedures I will invoke, I decide to keep them as enum:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DataLayer
{
    public enum StoredProcedure
    {
        CountrySelectAll, 
        LeagueSelectByCountry,
        TeamAllSelect,
        MatchInsert
 //...
    }
}

The Data layer will be constituted of an abstract base class named DataLayerBase and in it there will be a private element that implements the IDatabase interface from CsharpGears.Database. All database entity objects (discussed earlier) implement that interface. There are also wrapper methods over the methods for adding parameters in the database entity objects. The method Execute() is abstract, meaning all classes that will inherit from this class will also have to provide implementation of it. The method AddParameters() is used to hold all the parametrization of the call to the database. Lets now see how the inherited class would look like:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using CommonObjects;
using DevGears.DataBase;

namespace DataLayer
{
    public class TeamAllSelect : DataLayerBase
    {
        private List<Team> resultSet;

        public List<Team> ResultSet
        {
            get { return resultSet; }
            set { resultSet = value; }
        }

        protected override void AddParameters()
        {
            throw new NotImplementedException();
        }

        public override void Execute()
        {
            DbEntity = new GenericDbEntity<Team>(StoredProcedure.TeamAllSelect.ToString(),
                                                    ConnectionString);
            resultSet = (List<Team>)DbEntity.Select();
        }
    }
}

Since we don't need to add parameters to this stored procedure, we decide not to implement the AddParameters() method and leave it like it is. The CommonObject in our case, is the Team class:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace CommonObjects
{
    public class Team
    {
        #region Private Members
        private int teamId;
        private string name;
        private string presentationName;
        private string logoUrl;
        private string city;
        private string coordinates;
        private int leagueId;
        private int stadiumId;
        #endregion Private Members

        #region Properties
        public int StadiumId
        {
            get { return stadiumId; }
            set { stadiumId = value; }
        }

        public int LeagueId
        {
            get { return leagueId; }
            set { leagueId = value; }
        }

        public string Coordinates
        {
            get { return coordinates; }
            set { coordinates = value; }
        }

        public string City
        {
            get { return city; }
            set { city = value; }
        }

        public string LogoUrl
        {
            get { return logoUrl; }
            set { logoUrl = value; }
        }

        public string PresentationName
        {
            get { return presentationName; }
            set { presentationName = value; }
        }

        public string Name
        {
            get { return name; }
            set { name = value; }
        }

        public int TeamId
        {
          get { return teamId; }
          set { teamId = value; }
        }
        #endregion Properties
    }
}

Now, going upper to the business tier, we have the following BAL object:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace BusinessLayer
{
    public abstract class BusinessLayerBase
    {
        public abstract void Invoke();
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using CommonObjects;
using DataLayer;

namespace BusinessLayer
{
    public class TeamAllSelectProcess : BusinessLayerBase
    {
        private List<Team> resultSet;

        public List<Team> ResultSet
        {
            get { return resultSet; }
            set { resultSet = value; }
        }

        public override void Invoke()
        {
            TeamAllSelect teamAllSelect = new TeamAllSelect();
            teamAllSelect.Execute();
            resultSet = teamAllSelect.ResultSet;
        }
    }
}

Now, the cherry in the cream. In the presentation layer, we have an user control containing dropdown list that we want populated:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using CommonObjects;
using BusinessLayer;
using System.Drawing;

namespace FiksApp.UserControls
{
    public partial class HeadToHead : System.Web.UI.UserControl
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            if (!Page.IsPostBack)
            {
                TeamAllSelectProcess teamAllSelectProcess = new TeamAllSelectProcess();
                teamAllSelectProcess.Invoke();
                ddlTeam1.DataSource = teamAllSelectProcess.ResultSet;
                ddlTeam1.DataBind();
            }
        }
    }
}

That is all practically. I have guided you in a thorough process of designing the DAL and BAL of web application using the benefits of the CsharpGearsFramework. It would be nice to hear your comments, as they encourage me to further extend the framework and go on writing more posts.

CsharpGears Framework : Object-Relational Mapping

noreply@blogger.com (Unknown) — Fri, 28 Aug 2009 15:33:00 +0000

Reasons for Object-Relational Mapping

Since the rapid development of the relational databases and the acceptance of the Object-Oriented Programming model, a new need rose: to quickly and correctly map the persistance medium model (namely, the SQL tables) to the business objects in some high level programming language (C# for instance). Developers noticed that they invest significant amount of time writing the Data Access Layer (DAL) when starting off a new project, so they started looking for ways to decrease that time and effort. As time went by, several companies started producing software to efficiently map the SQL tables into business classes. Today, numerous of them are fairly famous, such as the NHibernate, SubSonic, Microsoft's Entity Framework, LINQ, etc. You can find more detailed list of ORM software on wikipedia.

Benefits of the ORM

The main benefits from using ORM software can be distinguished in the following categories:

Far less time spent on writing the DAL
Less errors on the low level of your application
Robustness and easy maintenance, cleaner code in the Business Access Layer (BAL)

Object-Relational Mapping (ORM) with C# Gears Framework

I have thought of a way to offer ORM functionalities from my framework, and I think it is quite efficient, although it does not yet offer all the bells and whistles of other frameworks that exist today. For now 5 projects are built on top of the framework, and its ORM capabilities have proven to be very easy to deploy, flexible and easy to use. Basically, the GenericDbEntity is able to map the columns from the SQL datareader to the columns of the C# class and as a result of the query execution, it returns a generic list with such business objects. The query result data is avaliable for business logic immediately after its fetch from the database. By that I have measured I spend in average 60 - 70 % less time on development of the DAL. However, this number will vary from project to project, and as I use it on more projects I will be able to give more accurate percentage of the time saving. The ORM part of the CsharpGears Framework utilizes the generics and code reuse capabilities of C#, which are one of the biggest strengths of the OOP.

Example: Using the ORM capabilities within the CsharpGears Framework

Lets consider the following situation. Imagine you are writing ASP.NET application for an e-shop. You have SQL table in the database that holds the products which looks like this:

As you can see, there is nothing unusual with this table. Let's say that we want to write a procedure that retrieves all products in given category:

CREATE PROCEDURE ProductsInCategory_Select
(
 @CategoryId BIGINT
)
AS
BEGIN    
    SELECT
            ProductID
            SUBSTRING(Description,1,15) + '...' AS Description,
            ImageUrl,
            Price,
            Date,
            Title,
            Product.CategoryID,
            Name AS categoryName,
            ThumbnailUrl AS thumbnailUrl
    FROM
            Product INNER JOIN Category ON Product.CategoryID = Category.CategoryID
    
    WHERE
            Product.CategoryID = @CategoryID
END

... and lets assume that we have the following business classes:

public class Category
    {
        #region Attributes
        long categoryId;
        string categoryName;
        #endregion Attributes

        #region Constructors
        public Category() { }
        #endregion Constructors

        #region Properties
        public string CategoryName
        {
            get { return categoryName; }
            set { categoryName = value; }
        }

        public long CategoryId
        {
            get { return categoryId; }
            set { categoryId = value; }
        }
        #endregion Properties
    }

public class Product
    {
        #region Attributes
        private long id;
        private string title;
        private string description;
        private double price;
        private DateTime date;
        private string imageUrl;
        private string thumbnailUrl;
        private Category category;
        private int quantity;
        #endregion Attributes


        #region Constructors
        public Product()
        {
            category = new Category();
        }
        #endregion Constructors

        
        #region Properties

        public long CategoryId
        {
            get { return category.CategoryId; }
            set { category.CategoryId = value; }
        }
        public string CategoryName
        {
            get { return category.CategoryName; }
            set { category.CategoryName = value; }
        }
        public string ThumbnailUrl
        {
            get { return thumbnailUrl; }
            set { thumbnailUrl = value; }
        }

        public string ImageUrl
        {
            get { return imageUrl; }
            set { imageUrl = value; }
        }
        public DateTime Date
        {
            get { return date; }
            set { date = value; }
        }

        public double Price
        {
            get { return price; }
            set { price = value; }
        }

        public string Description
        {
            get { return description; }
            set { description = value; }
        }


        public string Title
        {
            get { return title; }
            set { title = value; }
        }

        public long Id
        {
            get { return id; }
            set { id = value; }
        }

        public Category Category
        {
            get { return category; }
            set { category = value; }
        }

        public int Quantity
        {
            get { return quantity; }
            set { quantity = value; }
        }
        
        #endregion Properties
    }

Then, in order to retrieve the products as a generic list, I would just use the following code:

GenericDbEntity<Product> dbEntity = new GenericDbEntity<Product>("ProductsInCategory_Select", ConnectionString);
            dbEntity.IntAddCommandParameter("@CategoryId", 1);
            List<Product> resultSet = (List<Product>)dbEntity.Select();

And that is practically, it. I am immediately ready to work with my business objects (Products in this case). As you can observe, the CsharpGears easily handles class composition and once again proves flexibility. This ease of use comes from the fact that the framework directly maps the SQL columns into the properties of the C# class - no static mapping is requiered. Hence, by writing a simple property I could handle composition of objects without any unnecesary code.

Summary Note

As stated in the example above, the ORM software offers time saving techniques when writing software applications and makes the software more flexible and robust. A number of good tools already exist, but the free CsharpGears Framework also offers ORM functionalities efficiently. This framework does not intend to compete with LINQ or Entity Framework, but can come in handy when someone is still unfamiliar with them, or just wants a simple way to access data from the database and work with it in the application as business objects. The CsharpGears Framework so far has been reported to cut time spent on developing DAL up to 70 % and I hope in future I will be able to give more accurate percentages.

CsharpGears Framework : Using Different SQL Providers

noreply@blogger.com (Unknown) — Fri, 28 Aug 2009 11:33:00 +0000

Hello, I am about to present you how easily can you connect different types of databases with the C# Gears Framework. First of all, note that the IDatabase interface implementators do not care to what type of database they are connected to, they only care about the SQL query they need to execute. For example, here is how would you use C# Gears Framework in order to connect MySQL Database with .NET:

Connecting MySQL with C#

Step 1:Download and install the MySQL provider for .NET. Simply go to MySQL's download site and create an account if you already don't have one. The installation is pretty straightforward - there is a MSI installer.

Step 2:Add the MySQL.data.dll to your project. Ordinarily create new project in Visual Studio, go to References, right click on it and choose Add Reference. Then navigate to the path where the installation of the MySQL provider resides, and choose the mentioned dll.

Step 3: Start using the MySQL data provider. Now I will paste the whole code from my Default.aspx.cs file:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using MySql.Data.MySqlClient;
using CsharpGears.DataBase;
using System.Data;
namespace MySQLTest
{
    public partial class _Default : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {

            DataBaseEntity dbEntity = new DataBaseEntity("Select * FROM `product`",
CommandType.Text, 
"server=localhost;database=testdb;uid=root;password=", "MySql.Data.MySqlClient");
            DataTable dt = (DataTable)dbEntity.Select();
            foreach (DataRow dr in dt.Rows) 
            {
                Response.Write(dr["ID"].ToString() + ": " + dr["Description"].ToString() + 
" - " + dr["Date"].ToString());
            }
        }
    }
}

And that is it! You see, there is no difference in the usage of the DataBaseEntity object, you only use a different constructor which takes the connection string and the data provider as its parameters. The rest of the parameters are explained in the previous posts - it's just an ordinary ad-hoc SQL query call. I hope that the C# Gears Framework is helpful to you, as it saves a lot of time that would be otherwise spent on writing tedious code.
One last note before I go, this article assumes that you already know how to create MySQL database and it is not intended to be MySQL.NET tutorial. The author is sure you can find plenty of sources throughout the Internet on how to create MySQL database. Personally, i prefer the phpMyAdmin application for managing MySQL databases. PhpMyAdmin comes with the installation of WAMP (Windows-Apache-MySQL-PHP). You should also keep in mind that you need to start Apache in order to access the database from ASP.NET

CsharpGears Framework : Database Access: Output Parameters

noreply@blogger.com (Unknown) — Thu, 27 Aug 2009 09:37:00 +0000

Sometimes it is required that the stored procedures have output parameters. The CsharpGears can handle that too. There is another class in the Database namespace, that specializes working with output parameters. It is called DataBaseOutputEnabledEntity . Here is an example on how it's used:

DataBaseEntity dbEntity = new DataBaseEntity("GetProductByID");
DataBaseOutputEnabledEntity outputEnabledDbEntity = new DataBaseOutputEnabledEntity(dbEntity);
            outputEnabledDbEntity.AddCommandParameter("@NumberOfProducts", null, DbType.Int32);
            DataTable results = (DataTable)outputEnabledDbEntity.Select();
            int outputParamValue = (int)outputEnabledDbEntity.GetOuputParameterValue("@NumberOfProducts");

As you can see, as usual, I first create DataBaseEntity object and bind it with the stored procedure "GetProducts" (which is not shown here, but we assume it resides on SQL server). Lets assume that that stored procedure has one output parameter named @NumberOfProducts and it stores the number of products returned by the stored procedure. (This may be trivial example, but its nature is purely for demonstration purposes). Then I create a DataBaseOutputEnabledEntity object and bind it with the DataBaseEntity I have previously created. When using the AddCommandParameter() method from the DataBaseOutputEnabledEntity class, it basically adds DbParameter-s with the direction set to Output. In order to invoke the stored procedure, the only thing that needs to be called is the Select() method. If you are wondering how are you going to read the value from the output parameter after the query execution, here is the solution: you only need to invoke the GetOutputParameterValue() with the name of the parameter. It is that easy to invoke stored procedures with output parameters using the CsharpGears Framework. If you have not downloaded it that yet, I encourage you to do it here

Little note for the software designers here: DatabaseOutputEnabledEntity basically follows the Decorator Design Pattern as its constructor takes an IDatabase object. I have made this decision so that it offers more flexibility and extensibility. In this case, that proved to be a good decision. But as I learn more and more about design patterns, it becomes clear that they should be the applied as a refactoring method, because when you are trying to develop a solution to a particular problem, you need to focus on the problem, not on some UML diagrams for patterns. In future I will write more about design patterns. That's it, for now.

CsharpGears Framework : Database Access- SQL Transactions

noreply@blogger.com (Unknown) — Wed, 26 Aug 2009 17:59:00 +0000

Once you understood the basic ways of utilizing the CsharpGears Framework Database Access, now I will show you how to treat the SQL queries as transactions. Please note that in order to use the SQL transactions entities, you first need to add a reference to the System.Transactions namespace. After that, using the transaction database entity is very easy and similar to the previous examples:

TransactionDbEntity<LogMessage> tDbEntity = new TransactionDbEntity<LogMessage> ("LogRead",ConnectionString);
List<LogMessage> list = (List<LogMessage>)(tDbEntity.Select());

Here I consider retrieving the log from a database as list of LogMessage instances. The LogMessage class basically contains ID, Sender, Description and Date properties that need to be bound.This Database entity essentially creates CommitableTransaction object inside and commits it if the query passes successfully, otherwise performs rollback. But once again, my point was to show you how easy is to treat queries as transactions. Nevertheless, you can still write the transaction handling in the storet procedure's body, but just in case you have already written hundreds of procedures without database transactions, this class might come in handy.

CsharpGears Framework : Database Access

noreply@blogger.com (Unknown) — Wed, 26 Aug 2009 00:48:00 +0000

You have worked with databases, right ? Has it happened to you, to figure it out that it would be great if you could somehow magically map your SQL tables in neat C# classes ? Well, it's not that I am discovering new continents here, but I personally think that the Database Access sublibrary will effectively and easily allow you to map your database tables into C# classes. Among the other benefits, these classes can also come in handy if you wanted to treat some SQL queries as transactions and roll them back in case of error. You can also invoke stored procedures or simply pass ad-hoc queries to the database with just a few lines of code.

But what truely makes this library awesome, is it's ability to directly return lists of business objects. You don't even have to explicitely bind the class' properties to the SQL tables (as with Attributes). The Framework only requires that the name of the public property is the same as the name of the SQL table column. Have I mentioned that the library is absolutely generic ? It can accept any types of objects, as long as they have default constructor (which could be observed as limitation, but it is so simple to write it, that is no big deal). Well, enough introductory notes, let me show you what library can really do.

DatabaseEntity
This is the basic class in this library. It provides the basic functionality such as communicating with the database by executing queries. There are several constructors available which will allow you to choose your connection string to the database, the SQL provider, the type of the query (Stored procedure or ad-hoc query) etc. The DatabaseEntity class provides the four main query types in SQL: Select, Insert, Update, Delete. Please note that the Select query returns object which is actually DataTable (boxed). You need to cast it to DataTable for the sake of reusability of the code. So here is how it works.
Say you have the following table named Product with the following columns in the database:
ID | Description | Price

Then suppose that I wanted to retrieve all Products from the SQL table Product. I write the following procedure:

CREATE PROCEDURE ProductsGetAll_Select
AS
BEGIN
SELECT
      ID,
      Description,
      Price
FROM
      Product
END

Then back in C#, I need to create DataBaseEntityobject:

string ConnectionString = "...";
string DbProvider = "System.Data.SqlClient";
DataBaseEntity dbEntity = new DataBaseEntity("ProductsGetAll_Select",ConnectionString, DbProvider);

DataTable dtResults = (DataTable)dbEntity.Select();

foreach(DataRow dr in dtResults)
{
Console.Write(dr["ID"] + " " + dr["Description] " " + dr["Price"]);
}

So basically, that is all you need to do in order to retrieve your data from the database. For other types of SQL queries you just need to invoke the appropriate method (namely Update, Insert, Delete).

Using the DataBaseEntity class for ad-hoc SQL queries

DataBaseEntity dbEntity = new DataBaseEntity("SELECT * FROM Product", CommandType.Text, ConnectionString);
DataTable dt = (DataTable)dbEntity.Select();

GenericDbEntity

Well, I have mentioned that this library is able to directly return lists of business objects instead of returning DataTable. This is good simply because you won't bother to map those nasty data rows into your own objects. So here is how it goes:

public class Product
{
  private int id;
  private double price;
  private string description;
 
  public Product(){}

  public string Description{ get{return description;} set{description = value;}}
  public double Price{get{return price;} set{price = value;}}
  public int Id {get {return id;} set {id = value;}}
}

...

Binding SQL results to C# Objects

SELECT Query to C# objects example

GenericDbEntity dbEntity = new GenericDbEntity("ProductsGetAll_Select",ConnectionString, DbProvider);
List<Product> listOfProducts = (List<Product>)dbEntity.Select();

INSERT Query

GenericDbEntity dbEntity = new GenericDbEntity("Product_Insert",ConnectionString, DbProvider);
int newlyInsertedId = Convert.ToInt32(dbEntity.Insert());

UPDATE Query

GenericDbEntity dbEntity = new GenericDbEntity("Product_Update",ConnectionString, DbProvider);
dbEntity.Update();

DELETE Query

GenericDbEntity dbEntity = new GenericDbEntity("Product_Delete",ConnectionString, DbProvider);
dbEntity.Delete();


Adding Parameters to Database Entities

You can easily pass SQL parameters as well. Consider the following example:

dbEntity = new DataBaseEntity("GetProductByID");
            dbEntity.IntAddCommandParameter("@ProductID", 150);
            DataTable dt = (DataTable)dbEntity.Select();

Note the method IntAddCommandParameter() adds new DbParameter to the wrapped SQL command.

The first argument is the name of the parameter in the stored procedure, and the second is the actual value

we want to pass. There is also more generic AddCommandParameter() method which takes

the first two parameters just as the IntAddCommandParameter(), but it also takes a third parameter of DbType

to specify the type the database should treat it like.

That is literally, It. Nothing more is needed, indeed.

Please note that I am aware of various other approaches to this problem, such as the SQL Helper classes, Entity Framework etc, but simplicity this library bears makes it my first choice when it comes to communication with the database.

The CsharpGears Framework

noreply@blogger.com (Unknown) — Wed, 26 Aug 2009 00:13:00 +0000

I introduce you my development framework: CsharpGears. It is written in C# and its purpose is to speed up the development process, especially in the fundamental levels. It is meant to make developer's life easier when it comes to writing code such as accessing databases and mapping SQL tables into business objects ( C# classes ), or also for easy work with images, or other types of services, such as loggers or quickly writing code for RSS publishes, or maybe that tedious code for sending emails...
I personally find it very time-saving, and I hope that someone else out there will find it useful. To summarize, the CsharpGears Framework currently consists of six sublibraries:

Database access
Logger activities
E-mail sending
Working with images
RSS builder
URL rewriting policies

Each component will be covered in details in the following posts. Examples of its usage will also be included. Remember that you are able to download the class libraries for free.

Installation of the CsharpGears Framework
All you need to do in order to utilize the benefits of my framework is to : (1)download it from the downloads section, (2) add it as reference to any .NET project you would like to use it in.

End Note
I would also emphasize once again that I would be very happy first if someone else decides to use my framework, but I would be even happier if you provide me with your feedback.

Free C# libraries and examples

noreply@blogger.com (Unknown) — Tue, 25 Aug 2009 23:44:00 +0000

Hello everybody!

This blog is dedicated to publishing for download some of my class libraries I have written in C#. I hope you will find my classes useful and I sincerely encourage you to send me feedback about your experience. Any suggestions, critics and ideas are welcome. All the code examples and libraries will be absolutely free. OK, so it is time to see sharp...