Suman Chakrabarti - SharePoint and ASP.NET blog : .NET

Presentation at CodeCamp Pittsburgh

Suman Chakrabarti — Mon, 14 Apr 2008 18:47:48 GMT

I presented a Silverlight 1.0/2.0 demonstration yesterday at CodeCamp and it went quite well. Most importantly, it compiled; hey, that's half the battle.

The talk started out about how POX is not truly a ReST service because POX services are not usually provided as post-able services that control and manage information processing. With POX services, the idea is really to share the information with the user interface. So, I put together a service that provided customer order information from the AdventureWorks catalog. The information was provided in JSON format to the front end Silverlight 1.0 and 2.0 interface.

The Silverlight 1.0 portion of the demo went really fast, mainly because I kept the JavaScript in code snippets so I wouldn't end up debugging any of it. The Silverlight 2.0 piece took some time because I had to write all the code from scratch because I forgot to save the code in snippets. It did look like I knew what I was doing, though.

Anyways, thanks to Mike Snell, Craig Oaks, and Dave Hoerster for hosting CodeCamp! It was a fun time and I got to eat burritos.

Advanced UserControl stuff for easier customization

Suman Chakrabarti — Thu, 29 Nov 2007 03:29:00 GMT

I put together this post on my old blog about 2 years ago and was recently asked questions about this tip. I figure it will get more readership on my MSDN blog, so here goes.

There are some great advantages of UserControls, but the favored advantage is the fact that it does not require recompilation of code to change the look & feel of content.

User controls are web controls. Let's say you want to do some sort of skinning on a user control? Here's a simple method to give your user controls a heading--like a web part heading. This code will give you the ability to skin the heading of your user control and allow you to place content within the user control on the ASPX page

[ParseChildren(true, "WebPartContent")] public class WebPart : UserControl { protected Label WebPartTitle; protected PlaceHolder WebPartContentPlaceholder; [Browsable(false)] public PlaceHolder WebPartContent { get { return WebPartContentPlaceholder; } set { WebPartContentPlaceholder = value; } } [Browsable(true)] public string Title { get { return WebPartTitle.Text; } set { WebPartTitle.Text = value; } } }

The ASCX control can look like this:

<div class="individual-layout"> <div class="heading"> <div class="heading-title"><asp:Label runat="server" id="WebPartTitle" /></div> <div class="heading-collapse-button"><asp:Button runat="server" id="HideButton" /></div> </div> <div> <asp:Placeholder runat="server" id="WebPartContentPlaceholder" /> </div> </div>

And the ASPX page can look like this:

<body> <uc:WebPart runat="server" Title="Web part title"> This is where my user control content will go... </uc:WebPart> </body>

How does this work? Someone recently asked me how this works. Well, it's important to understand webcontrol development to understand what's going on here. The [ParseChildren] attribute is giving the runtime a hint that the XML within my runat=server tag is really meant to be housed within another control. It acts like an XML schema <xs:any> tag and puts my content within my WebPartControlPlaceholder PlaceHolder's Controls collection. This is very similar to the way MasterPages are done in ASP.NET 2.0+.

Anyways, I thought it was a good tip.

SharePoint development best practices on MSDN

Suman Chakrabarti — Fri, 16 Nov 2007 15:28:22 GMT

Some great articles on SharePoint best practices have been published on MSDN.

Surface Computing

Suman Chakrabarti — Mon, 11 Jun 2007 01:42:00 GMT

I've got to say the surface computing stuff is the coolest new invention. I can't wait to see this in restaurants.

Here are some great links and videos (yes, it’s ironic that the best online press is available through Google’s YouTube):

http://www.microsoft.com/surface
http://www.youtube.com/results?search_query=microsoft+surface

I think it's important to note that under the covers, there is still Windows Vista and the Windows Presentation Foundation.

Active Directory Activities for Windows Workflow Foundation posted

Suman Chakrabarti — Thu, 21 Dec 2006 19:06:00 GMT

My Active Directory activities have been published to the .NET 3.0 web site. They are available here: http://wf.netfx3.com/files/folders/communications/entry7716.aspx

I've included a simple sample and I will probably tag in an screenshot of a sample workflow.

Enjoy!

System.Data.Common data connections: Part 1 - Connecting with ConnectionStringSettings

Suman Chakrabarti — Thu, 11 May 2006 20:02:00 GMT

This is a demonstration of how to connect to data sources using the DB provider-based objects built into the .NET 2.0 framework. I've noticed a bit of confusion around programming for the new structures, so I'm going to put together a little guide on how to access data with this newly built-in, provider-driven model.

In the .NET 2.0 data objects, a new namespace has been born....System.Data.Common. Its purpose is to abstract data logic from the code interaction with a specific database. This method is not new, but it is much easier to implement in the 2.0 framework and it provides a 'patterned' way of development.

IMO, I highly recommend using the abstract class model in every scenario of data-driven development. Much like when everyone in the office buys a lottery ticket and I, the "anti-gambler", buy a ticket; it's purely preventative. I don't want to go down when everyone else wins, and you don't want to rewrite your data layer when the boss asks how long it will take to implement the same app with an Oracle DB.

Enough of the rant and down to code.

There are a few new classes that provide the construct for this kind of development:

System.Data.Common.DbProviderFactories - provides a means of initilizing the appropriate concrete provider
System.Data.Common.DbProviderFactory - the initialized concrete provider
System.Configuration.ConnectionStringSettings - provides a means of storing/retrieving a data connection string and the provider to initialize.

First things first, let's talk about the Connection Strings. The connection string format in the configuration file is the following:

<connectionStrings>
    <add name="DataConnectionString"
        connectionString="Provider=Microsoft.Jet.OLEDB.4.0;
                Data Source=|DataDirectory|\AdventureWorks.mdb"
        providerName="System.Data.OleDb" />
</connectionStrings>

The parts of the System.Configuration.ConnectionStringSettings object are:

Name - the name of the connection string that is used for looking up the ConnectionStringSettings object
ConnectionString - the connection string that is to be passed into the proper DB connection object
ProviderName - the data provider factory name which will initialize a concrete instance of the appropriate DB connection class

NOTE: Before demonstrating the data provider factory connection method, it's important to note that if you are never going to switch between providers (Oracle, MS SQL Server, MySQL, OleDB), then the provider factory method can be skipped and you can simply use the connection string with its corresponding provider (ex: new SqlConnection(ConnectionString)).

The following code illustrates how to create a DB connection using the data provider classes. Notice that this connection method provides an approach to getting a connection from an already created DbProviderFactory. The idea is to create a collection of already initialized providers, then all you are calling at runtime is the GetConnection() method of the DataManager class. Additionally, IMO, I believe the returned connection should be stored in a local variable and reused rather than disposed.


using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data.Common;
 
public static class DataManager {
 
    public static Dictionary<string, DataConnection> _dbConnections;
 
    static DataManager() {
        // initialize the db factories
        _dbConnections = new Dictionary<string, DataConnection>(
            ConfigurationManager.ConnectionStrings.Count);
 
        foreach (ConnectionStringSettings cstring in
            ConfigurationManager.ConnectionStrings) {
 
            // initialize a new DbProviderFactory
            DbProviderFactory factory =
                DbProviderFactories.GetFactory(cstring.ProviderName);
 
            // Initialize a new DataConnection object
            DataConnection connection =
                new DataConnection(cstring.ConnectionString, factory);
 
            // add the DataConnection to the dictionary
            // names will be unique because they are unique for
            // the ConnectionStringSettingsCollection object
            _dbConnections.Add(cstrings.Name.ToLower(), connection);
        }
    }
    /// <summary>
    /// Gets a connection using the configuration
    /// connection string name.
    /// </summary>
    /// <param name="connectionStringConfigName">
    /// The name of the connection in the configuration file.
    /// </param>
    /// <returns>
    /// An instantiated DbConnection with the applied connection string.
    /// </returns>
    public static DbConnection GetConnection(
        string connectionStringConfigName) {

        if (!_dbConnections.ContainsKey(
            connectionStringConfigName.ToLower()))
            throw new ConfigurationException(
                "The data provider could not be initialized. "+
                "Please recheck the configuration file.");
 
        DataConnection cn = _dbConnections[
            connectionStringConfigName.ToLower()];
        return cn.CreateConnection();
    }
 
    private class DataConnection {
        string _connectionString;
        DbProviderFactory _dbFactory;
 
        internal DataConnection(
            string connectionString,
            DbProviderFactory factory) {
 
            _connectionString = connectionString;
            _dbFactory = factory;
        }
        public DbConnection CreateConnection() {
            DbConnection connection = _dbFactory.CreateConnection();
            connection.ConnectionString = ConnectionString;
            return connection;
        }
    }
}

If you like this approach, I am going to go on about data connections in a future "Part 2" blog entry. I will go over the idea of creating a data provider for multiple data sources using an abstract factory provider.

Custom collections data pattern

Suman Chakrabarti — Fri, 05 May 2006 21:57:00 GMT

I've put together a simple pattern for when I create new data driven objects that I'd like to share. This is the method I used in the 1.x framework for easily managing data objects. This is my version of the Lightweight Business Objects (LBO) approach.

BaseDataObject Class

Let's take the situation where I have several data objects and I want to maintain all the object properties easily. I create an abstract base class that represents a data object (public abstract class BaseDataObject). The abstract class contains a default constructor that initializes a Hashtable where data properties are stored. Then create an oveloaded constructor that has an argument for the System.Data.IDataReader:

internal BaseDataObject(){
    _properties = new Hashtable();
}
internal BaseDataObject(IDataReader properties) : this() {
    // writes data to properties collection
    WriteData(properties);
}

The overloaded constructor calls a WriteData method which copies data from the DataReader to the Hashtable:

void WriteData(IDataReader properties) {
    if (properties.IsClosed)
        throw new DataException(
          "The IDataReader properties must be " +
          "set to initialize a new Customer");
 
    // the name that the value is stored under
      // is the name provided from the data source
    for (int i = 0; i < properties.FieldCount; i++) {
        BaseSet(properties.GetName(i).ToLower(), properties[i]);
    }
}

I also provide methods to access the base data properties. These are the BaseGet<T> and BaseSet methods:

protected internal T BaseGet<T>(string name) {
    return BaseGet<T>(name, default(T));
}
protected internal T BaseGet<T>(string name, T defaultValue) {
    if (_properties[name] == null)
        return defaultValue;
    return (T)_properties[name];
}
protected virtual internal void BaseSet(string name, object value) {
    _properties[name] = value;
}

This approach makes it easy to get a properly cast object and set a property in the hashtable cleanly. This also provides a central location to create functionality around setting data properties. An example could be an IsDirty property or PropertyChanged event. Subclasses will use the BaseGet and BaseSet methods to set properties they want to expose.

Next, I attach a Save method. Because the Save method is going to be different for every object, it would normally be an abstract method; however, I take this as an opportunity to setup two events: Saving and Saved. These events can be used to cancel the data save or maybe to redirect the user to another location when the data has been saved. Here is the Save method:

public void Save(){
    // perform an action on the data before saving
    // (possibly security validation)
    CancelEventArgs args = new CancelEventArgs();
    OnSaving(args);
    
    if (args.Cancel) return;
    
    // save the data
    SaveInternal();
    
    // provide event for after the item is saved
    OnSaved(args);
}
// this is overridden in subclasses to handle saving the object data
protected internal abstract void SaveInternal();
 
public event CancelEventHandler Saving;
public event EventHandler Saved;

Notice that instead of providing an opportunity for a developer to override the Save method, an abstract method called SaveInternal is applied.

To view the completed BaseDataObject, click here.

Example: Customer class:

Now, I will make an example Customer class and demonstrate a controller class that will populate my data object.

public class Customer : BaseDataObject {

    public Customer() : base() { }
    internal Customer(IDataReader properties) : base(properties) { }
    
    // the property name ID differs from the database name CustomerID
    public int ID {
        get { return BaseGet<int>("customerid", 0); }
    }
 
    public string FirstName {
        get { return BaseGet<string>("firstname"); }
        set { BaseSet("firstname", value); }
    }
 
    public string LastName {
        get { return BaseGet<string>("lastname"); }
        set { BaseSet("lastname", value); }
    }
 
    protected internal override void SaveInternal() {
        // DataManager is the static data class
        // it provides CRUD data actions
        DataManager.SaveCustomer(ID, FirstName, LastName);
    }
}

CustomerManager class:

The CustomerManager class manages interactions between the CRUD data object (which I generally build using the System.Data.Common namespace) and the business logic. So examples might be to get all the customers or get a customer by ID as in the example below:

public static class CustomerManager {
    public static List<Customer> GetCustomers() {
        List<Customer> customers = new List<Customer>();
 
        using (IDataReader data = DataManager.GetCustomers()) {
            while (data.Read()) {
                Customer customer = new Customer(data);
                customers.Add(customer);
            }
        }
        return customers;
    }
    public static Customer GetCustomer(int customerID) { 
        using (IDataReader data = DataManager.GetCustomerByID(customerID)) {
            if (data.Read()) {
                Customer customer = new Customer(data);
                return customer;
            }
        }
        return null;
    }
}

You'll notice that the data from the CustomerManager object is used to abstract the data logic from the business logic.

Now, to approach an actual case of using these objects, check out the following:

// get all customers
List<Customer> customers = CustomerManager.GetCustomers();

// get a single customer
Customer customer = CustomerManager.GetCustomer(23);
// modify customer and save

customer.FirstName = "foo";
customer.LastName = "bar";
customer.Save();

Let me know what you like or dislike about my approach. It's nothing great, but it works well and is better than the Typed DataSets (IMO).

BaseDataObject class:

public abstract class BaseDataObject {
    private Hashtable _properties;
    
    internal BaseDataObject(){
        _properties = new Hashtable();
    }
    internal BaseDataObject(IDataReader properties) : this() {
        // writes data to properties collection
        WriteData(properties);
    }
    
    void WriteData(IDataReader properties) {
        if (properties.IsClosed)
            throw new DataException("The IDataReader properties must be " +
                        "set to initialize a new Customer");
 
        // the name that the value is stored under
        // is the name provided from the data source
        for (int i = 0; i < properties.FieldCount; i++) {
            BaseSet(properties.GetName(i).ToLower(), properties[i]);
        }
    }
    
    public void Save(){
        // perform an action on the data before saving
        // (possibly security validation)
        CancelEventArgs args = new CancelEventArgs();
        OnSaving(args);
        
        if (args.Cancel) return;
        
        // save the data
        SaveInternal();
        
        // provide event for after the item is saved
        OnSaved(args);
    }
    // this is used by 
    protected internal abstract void SaveInternal();
    
    public event CancelEventHandler Saving;
    public event EventHandler Saved;
    
    protected virtual void OnSaving(CancelEventArgs args){
        if (Saving != null)
            Saving(this, args);
    }
    
    protected virtual void OnSaved(EventArgs args){
        if (Saved != null)
            Saved(this, args);
    }
    
    protected internal IDictionary Properties{
        get { return _properties; }
    }
    

    protected internal T BaseGet<T>(string name) {
        return BaseGet<T>(name, default(T));
    }

    protected internal T BaseGet<T>(string name, T defaultValue) {
        if (_properties[name] == null)
            return defaultValue;
        return (T)_properties[name];
    }

    protected virtual internal void BaseSet(string name, object value) {
        _properties[name] = value;
    }
}