StaticGround

Derived classes and events

2007-12-20T11:19:00.000-08:00

Events are a useful feature of the C# language and allow for clients to be notified when the state of a server changes. You create an event by declaring it in the class that will raise the event:


public event EventHandler NotifyClient;

Here, I used the generic event template to eliminate the need to define a separate delegate. To register a callback method with the event, we do the following in the class that will receive the event notification from the class that raised the event:


message.NotifyClient += new EventHandler(message_NotifyClient);

static void message_NotifyClient(object sender, EventArgs e)
{
  throw new Exception("The method or operation is not implemented.");
}

When the event is raised the message_NotifyClient method will execute. To raise the event we add the following to the class that raises the event:


protected virtual void OnNotifyClient(EventArgs e)
{
  EventHandler handler = NotifyClient;

  if (handler != null)
      handler(this, e);
}

Here, we make a copy of the event since access to the event is not thread-safe (i.e. another thread could delete/modify the event before the if (handler != null) completes). When the client wants to raise the event, it does so by executing the OnNotifyClient method:


private void DoSomething()
{
 // Do something...
 OnNotifyClient(new EventArgs());
}

When OnNotifyClient is executed, the message_NotifyClient method is executed.

Derived classes and events
An event can only be raised from methods declare within the class that declared the event. So events declared in class A can only be raised from methods within class A. By default, events are not inherited by derived classes, so in the following base class definition:


public class Base
{
 public event EventHander NotifyClient;
}

with the derived class definition


public class Derived : Base
{
 private void DoSomething()
 {
   EventHandler handler = NotifyClient;

   if (handler != null)
       handler(this, new EventArgs());
 }
}

The derived class will not have access to the NotifyClient event since the NotifyClient event was not declared in the Derived class. There are two ways to workaround this requirement:

Define the OnNotifyClient method in the Base class as virtual and then override the OnNotifyClient method in the Derived class
Declare the event as virtual in the Base class, then override the event in the Derived class

You'll notice above that the OnNotifyClient method is declared with the virtual keyword. This allows the Derived class to override the OnNotifyClient method and access the NotifyClient directly. So, we could do this in the Derived class:


protected override void OnNotifyClient(EventArgs e)
{
 EventHandler handler = NotifyClient;

 if (handler != null)
   handler(this, e);
}

protected void DoSomething()
{
 // Do something Derived-class specific, then call OnNotifyClient
 OnNotifyClient(new EventArgs());
}

The second approach is to declare the event virtual in the Base class, then override the event in the Derived class:


public class Base
{
 public virtual event EventHandler NotifyClient;
 ...
}

public class Derived : Base
{
 public override event EventHandler NotifyClient;

 public void DoSomething()
 {
   EventHandler handler = NotifyClient;

   // Here, we can access the NotifyClient directly since we've overridden access
   if (handler != null)
       handler(this, new EventArgs());
 }
}

Which approach you take is up to you. Both approaches give the Derived class the flexibility to perform Derived-specific tasks around the decision to raise the event. It really comes down to which approach is preferred.

2007-11-28T11:44:00.000-08:00

When the pros of using reflection outweigh the cons, you can take advantage of using it when iterating over properties of classes. To help with debugging, you can override the ToString() of your classes to return a string that contains the name of any public properties along with their corresponding values:

        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
            Type t = this.GetType();

            PropertyInfo[] pInfo = t.GetProperties();

            sb.Append(t.ToString() + "\r\n");

            foreach (PropertyInfo p in pInfo)
            {
                string fmt = string.Format("{0} = {1}", p.Name, p.GetValue(this, null));

                sb.Append(fmt + "\r\n");
            }

            return sb.ToString();
        }

The function uses reflection to get the public properties of the class and it iterates over the collection of properties and builds a string that represents the state of the class. The string returned from ToString() would look like this:

Property1 = Value1
Property2 = Value2
.
.
.

The PropertyInfo.GetValue() function takes two parameters; the first parameter is the reference to this, while the second parameter is an object array that is used when the PropertyInfo references an indexed property. When using reflection to enumerate properties on a class that contains other classes, you must accomodate the case where a class might contain an indexed property:

public class Details
{
        public EDIProcess.Model.EstimateDetailType this[int index]
        {
            get { return (EDIProcess.Model.EstimateDetailType) DetailCollection[index]; }
        }
}

In this case, the Details class contains an indexer that is used to retrieve EstimateDetailType objects by index from the DetailCollection property. You can use the GetValue() function and pass in an object array that contains a single entry that is the value of the offset into the collection, which will reference the indexed item at that position within the collection.

public class Details
{
        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();

            try
            {
                Type t = this.GetType();
                string fmt;

                PropertyInfo[] pInfo = t.GetProperties();

                sb.Append(t.ToString() + "\r\n");

                foreach (PropertyInfo p in pInfo)
                {
                    if (p.Name == "Item")
                    {
                        for (int i = 0; i < Count; i++)
                        {
                            fmt = string.Format("{0} = {1}", p.Name, p.GetValue(this, new object[] { i }));
                            sb.Append(fmt + "\r\n");
                        }
                    }
                    else
                    {
                        fmt = string.Format("{0} = {1}", p.Name, p.GetValue(this, null));
                        sb.Append(fmt + "\r\n");
                    }
                }
            }
            catch (Exception ex)
            {
                log.Error(ex.Message);
            }

            return sb.ToString();
    }
}

The items in bold represent the changes to support the indexed properties. The Details class contains a DetailCollection class (which derives from ArrayList), and the Details class contains an indexer to retrieve an item from the collection as well as a property that returns the number of items stored in the collection. The modification looks for a property named Item in the Details class, and it then retrieves the count of objects in the collection and for each object in the collection it calls the GetValue(), passing in a reference to the Details class (this) and a new object[] array that contains a single member that stores the integer value of the item within the collection.

Threading in C#

2007-09-21T13:30:00.000-07:00

I found an interesting online resource on Threading in C#

2006-11-03T17:46:00.000-08:00

On the project that I am leading, I ran across an interesting issue using a combination of a stored procedure and the ISNULL SQL function. If we have the following table definition:

CREATE TABLE [dbo].[TEST_TABLE] (
[Data] [varchar] (5) COLLATE Latin1_General_BIN NOT NULL
)

and this table contains a row that contains:

Data
=====
ABCDE

Now, if we have a stored procedure that updates the row called UpdateData:

CREATE PROCEDURE UpdateData
@Data varchar(3) = null
AS

Begin Tran
update TEST_TABLE
set Data = ISNULL(@Data, Data)
IF @@ERROR <> 0
Rollback Tran
else
Commit Tran

The stored procedure sets the @Data variable to null by defualt, otherwise it will use the value passed to it via the @Data variable. The update statement uses the ISNULL function to check if the @Data variable is the default value of null and if it is, then it should use the current value in the Data column on the table. If we call this stored procedure, without passing in the @Data parameter, the stored procedure will set the value of the @Data parameter to null, and this is what we'll get:

Data
=====
ABC

What happened, why did my data get truncated? Think about how the ISNULL function works, it sets the variable specified in the first parameter to the value of the variable specified in the second parameter if the first parameter is null. So, it should set the @Data variable to the value in the Data column. Also note that the stored procedure is implicitly creating the @Data variable in the procedure declaration and also note that the @Data variable has a width of 3 varchars instead of the 5 varchars in the TEMP_TABLE Data column declaration. Essentially what happens is that the ISNULL function sees that the @Data variable is null, reads the Data column from the table and then copies the value from the Data column into the @Data variable. Since the @Data variable is only 3 varchars wide, only 3 varchars are copied to it. The set clause then updates the Data column with these 3 varchars from the @Data variable. That's why the data gets truncated. So, the moral of the story is to make sure of the following:

Your table column widths and your stored procedure widths match
You pass the right amount of data from your code to your stored procedure

SQL Server pseudo nested transactions

2006-10-04T12:21:00.000-07:00

SQL Server 2000 does not support nested transactions. So, if we have the following two stored procedures:

SP1:


create procedure sp1
as

begin tran
exec sp2

if (@@error <> 0) 
  goto on_error

commit tran

on_error:
rollback tran
 


SP1:
 create procedure sp2
 as
 
 begin tran
insert table values ('sp2')
 
 if (@@error <> 0) 
   goto on_error
 
 commit tran
 
 on_error:
 rollback tran

The rules for nested begin transactions is:

Any begin tran statements are ignored, but each begin tran statement does update the @@trancount variable.
Any commit statements executed after the first commit transaction statement are ignored. The transaction is committed only when the outermost commit statement is executed. The @@trancount variable is decremented by one for each commit statement executed.
Any rollback statements executed will rollback the entire transaction and set the @@trancount variable to 0.

Basically, I think of nested transactions as really just one main transaction that could contain multiple time points where the state of the transaction (committed, rollback) can be modified.

When using the ADO.NET SqlTransaction object you need to be aware of how transactions are committed and rolled back. When the SqlTransaction.BeginTransaction method is executed, it implicitly executes the BEGIN TRAN SQL statement. Any SQL statements executed will then execute on this main transaction. If the SQL statements that are executed perform a commit or rollback, the main transaction is affected based on the rules above. There may be certain cases where a servere SQL error will cause the main transaction to rollback, and if the main transaction is created by the SqlTransaction.BeginTransaction method, when the exception is caught, you will need to check if the transacion was actually already rolled back before executing the SqlTransaction.Rollback method:


try
{
    try
    {
       SqlTransaction txn = new SqlTransaction();

       txn.BeginTransaction();

       Data.CallSproc1();
       Data.CallSproc2();  // throws an exception and rolls back the transaction
       txn.CommitTransaction();
    }
    catch(SqlException ex)
    {
        txn.RollbackTransaction();  // If the transaction is already rolled back, this will throw an exception
    }
}
catch(SqlException ex)
{
    // Transaction was already rolled back, do something
}
 }

NTLM Explained

2006-10-02T17:55:00.000-07:00

If you want a good description of NTLM Authentication (Windows authentication), you can find a good resource here

2006-09-26T15:46:00.000-07:00

Dan Ciruli has a good post on software as a service (SAAS) in the trenches here. In it he talks about a number of concerns that CIO's raise. One of the concerns revolves around data security. Companies want to be able to own the only copy of their data (not in some vendor's database halfway across the country) and they want to have the ability to apply different levels of access to the data based on how the data is used. Having been involved in more than one SaaS projects, the discussions I've heard the same things over and over from clients: Where will my data live, and how will you secure it? In general, discussions usually go like this:

Project Lead: Your users can login to your own custom-branded site and use the system.
Customer: How do I limit access to the site?
Project Lead: We have an admin screen that you can use to setup users.

Customer: What if I want this integrated with my ActiveDirectory security? When a user quits, I want one way to turn off access to the application. Can I do that?

Project Lead: No, you'd have to use the admin tool to remove the user. We're working on the ActiveDirctory integration for the next release

Customer: Well, OK, so how do I prevent users outside of the company from going to the site and hacking into it?

Project Lead: We have a very secure data center.

Customer: What about data, where will it live?

Project Lead: At our data center.

Customer: So, if something happens to the data center, I won't have access to the data? What if your site is down, and what if this is our accounting system, then we can't use the system.

Project Lead: Well, yes, but we do have a service level agreement that we'd have to adhere to or your subscription will get reduced. Also, our data center also has a service level agreement.

Customer: I honestly don't really care about the reduced subscription rate, but at your prices this application needs to be bulletproof. I need access to this data 24-7. So, do you have a backup plan for my data?

Project Lead: of course.

Customer: OK, let me think about it. I'll get back to you.

The project lead goes back to the team and tells them to firgure out a way to integrate their application with ActiveDirectory. The project lead also has some conversations with their hosting site. The customer discusses purchasing the service with the executive management team. The customer calls the project lead up:

Customer: Well, I talked with the management here, and they had some concerns over data access.

Project Lead: Our security policies are very comprehensive, your data will be secure.

Customer: I can't guarantee that my data will be secure, unless I own the data, behind my firewall.

Project Lead: Well I see your point, but you won't be able to get the advantages of automatic feature upgrades and centralized administration if we are unable to access the application behind your firewall.

Customer: Access and control of our data is our biggest concern, the other 'features' are not essential. Also, how do we get the data out of your system? Can we export the data into Excel?

Project Lead: Well, we don't have an easy way of doing this, I suppose you could export most of the data to Excel, but some of the data will take a little more work to get to it.

Project Lead: What databases do you have available for use?

Customer: Oracle. Some MySQL.

Project Lead: Well, currently our application only works with SQL Server, and we'd need to make some modifications to give you the ability to host the application behind your firewall.

Customer: We like the features of the application, but having a system that we can host ourselves is a requirement. Let me know when you have an application that will integrate with our security model and our network architecture.

Project Lead: OK, I'll see what I can do...

I've seen most conversations with customers turn out like this, especially when you are trying to sell to the first handful of customers. As the number of customers increases, there's usually trust in numbers, so it becomes less of a concern if a potential client can see that other clients trust you with their data. I'm sure the first few customers that SalesForce tried to get had issues around data access and security. If you are unable to convince them to trust you with their data, you have two choices:

Convert your application into a hosted solution that the customer can install on their own servers and manage. Don't forget to think about how they will install and upgrade the application. And security. And data migration from legacy systems. And browser support. And rollback strategies.
Try and convince some other large enterprise customer that trusting you with their data is the only way to go.

2006-09-19T11:17:00.000-07:00

I was unable to find the documentation or a code sample that described how to configure the connectionString node in the dataConfiguration.config for the Data Access Application Block 2.0 (DAAB). I searched the web and Google groups and each example shown used Integrated Security. So, I had to take a look at the DAAB source code to figure out which parameters I needed to configure.

In Data Access Application Block 2.0 To specify the connection strings for both integrated security and SQL security, you configure the dataConfiguration.config file:

This will configure the DAAB to use SQL Security:


     <connectionStrings>
        <connectionString name="SQLSecConnStr">
          <parameters>
            <parameter name="database" value="Database" isSensitive="false" />
            <parameter name="uid" value="Test" isSensitive="true" />
            <parameter name="pwd" value="Test" isSensitive="true" />
            <parameter name="server" value="WWW.XX.YY.ZZ\SQLInstance" isSensitive="false" />
          </parameters>
        </connectionString>
      </connectionStrings>

This will configure the DAAB to use Integrated Security:


     <connectionStrings>
        <connectionString name="IntSecConnStr">
          <parameters>
            <parameter name="database" value="Database" isSensitive="false" />
            <parameter name="Integrated Security" value="true" />
            <parameter name="server" value="WWW.XX.YY.ZZ\SQLInstance" isSensitive="false" />
          </parameters>
        </connectionString>
     </connectionStrings>

Exceptions

2006-08-30T15:03:00.000-07:00

Exceptions

When throwing/handling exceptions you should be aware of a few things:

Take a look at the following code:


          try

          {

              db.ExecuteNonQuery(dbCommandWrapper);

              log.Debug("Executed: " + sqlCommand);

          }

          catch (SqlException ex)

          {

              throw new ApplicationException("Exception encountered while inserting data", ex);

          }

Notice a few things:

* I am catching a specific exception instead of catching the generic Exception. So instead of catching all exceptions, just catch the exceptions that you intend to handle.
* I am throwing a new exception of type ApplicationException, and I am wrapping the original exception into the InnerException property. This accomplishes two things: It gives the caller the ability to handle exceptions of type ApplicationException instead of handling Exception or SqlException typed exceptions. The case for this is that if the business tier calls the data tier and the data tier encounters a SqlException, then either the data tier should handle the SqlException and don't throw it, or create a new exception and wrap the SqlException and throw this new exception to the business tier. This eliminates the need for the business tier to try to handle SqlException exceptions when the Data tier should handle the SqlException. Another point to note is that you should probably stay away from using the following throw commands: throw; throw ex; and throw new ApplicationException("some message"); as all three will overwrite any stack trace for the exception up to the point when the throw was executed, so all past stack traces before the throw was executed will be lost.

Interesting discussions around Google's open API's

2006-08-24T20:23:00.000-07:00

Discussions about who really owns your data on the web and how you can access your data here

Concurrency on the web

2006-08-24T19:20:00.000-07:00

Lately, I've been noticing that more and more people are beginning to discuss concurrency and how it relates to the new multi core CPU's that are being released.

Kim Greenlee's blog post
Herb Sutter's article on concurrency
Musings about concurrency and manycore CPUs
Larry O'Brien

Most of the discussions center on how to design software to take advantage of multiple cores, and how to come up with an easy way to get developers interested in concurrency. Designing software to take advantage of multiple CPUs is familiar to most systems software engineers (operating systems, web servers, database servers, search engines), but most business applications are still designed to take advantage of a single CPU. Most business application developers are not familiar with concepts such as threading, synchronization, shared memory/data, deadlocks, etc. because the software that they build usually has the requirment that it perform one task at a time, in serial because there was never a requirement to run tasks in parallel. Even if there was a requirement to run tasks in parallel, it would probably be easier to install the system on a new machine and load balance both systems, since the cost of a new machine is less than the time/effort cost for the developer to redesign the system as a concurrent system.

From the business application developer standpoint there are two questions they will ask about concurrency: How can I split my application into different business processes that can run independently of one another? what's a thread? why would I use it? what's a lock? what's deadlock? All of these questions will need to get answered if the developer wants to take advantage of all of the computing power available to them. The questions around threads, locks, synchronization, etc. are easy to find answers to, there are lots of books/websites on the topic. The more difficult questions to answer are about how to divide applications into business processes that can run in parallel. Since every business application is different, there probably is no one right answer to this question, but I do feel that it is useful for developers to become familiar with how system engineers solve problems by programming for concurrency. Basically, I believe that we will start to see more and more design patterns that are used to solve concurrency problems. Martin Fowler's book: Patterns of Enterprise Application Architecture has a section on concurrency, and the book Data Access Patterns also has a section on concurrency, so these are two good places to start. For learning about multithreading, the book .NET Multithreading is a good one. There are a few frameworks that may make developing concurrent applications easier on the .NET platform:

Although not .NET-only, the framework OpenMP is another choice.

2006-08-22T10:32:00.000-07:00


        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
            Type t = this.GetType();

            PropertyInfo[] pInfo = t.GetProperties();

            sb.Append(t.ToString() + "\r\n");

            foreach (PropertyInfo p in pInfo)
            {
                string fmt = string.Format("{0} = {1}", p.Name, p.GetValue(this, null));

                sb.Append(fmt + "\r\n");
            }

            return sb.ToString();
        }

The function uses reflection to get the public properties of the class and it iterates over the collection of properties and builds a string that represents the state of the class. The string returned from ToString() would look like this:

Property1 = Value1
Property2 = Value2
.
.
.

The PropertyInfo.GetValue() function takes two parameters; the first parameter is the reference to this, while the second parameter is an object array that is used when the PropertyInfo references an indexed property. When using reflection to enumerate properties on a class that contains other classes, you must accomodate the case where a class might contain an indexed property:


public class Details
{
        public Main.Model.DetailType this[int index]
        {
            get { return (Main.Model.DetailType) DetailCollection[index]; }
        }
}

In this case, the Details class contains an indexer that is used to retrieve DetailType objects by index from the DetailCollection property. You can use the GetValue() function and pass in an object array that contains a single entry that is the value of the offset into the collection, which will reference the indexed item at that position within the collection.


public class Details
{
        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();

            try
            {
                Type t = this.GetType();
                string fmt;

                PropertyInfo[] pInfo = t.GetProperties();


                sb.Append(t.ToString() + "\r\n");

                foreach (PropertyInfo p in pInfo)
                {
                    if (p.Name == "Item")
                    {
                        for (int i = 0; i < Count; i++)
                        {
                            fmt = string.Format("{0} = {1}", p.Name, p.GetValue(this, new object[] { i }));
                            sb.Append(fmt + "\r\n");
                        }
                    }
                    else
                    {
                        fmt = string.Format("{0} = {1}", p.Name, p.GetValue(this, null));
                        sb.Append(fmt + "\r\n");
                    }
                }
            }
            catch (Exception ex)
            {
                log.Error(ex.Message);
            }

            return sb.ToString();
    }
}

The items in bold represent the changes to support the indexed properties. The Details class contains a DetailCollection class (which derives from ArrayList), and the Details class contains an indexer to retrieve an item from the collection as well as a property that returns the number of items stored in the collection. The modification looks for a property named Item in the Details class, and it then retrieves the count of objects in the collection and for each object in the collection it calls the GetValue(), passing in a reference to the Details class (this) and a new object[] array that contains a single member that stores the integer value of the item within the collection.

Retrieving class property values via reflection

2006-08-15T19:29:00.000-07:00

Recently I was implementing some logging code for some legacy C# classes that contained many public properties. Instead of implementing each property in the overriden ToString() of the class, I decided to use reflection to get the list of properties and print out their values:


  public override string ToString()
  {
   StringBuilder sb = new StringBuilder();
   Type t = this.GetType();

   PropertyInfo[] pInfo = t.GetProperties();

   sb.Append(t.ToString() + "\r\n");

   foreach (PropertyInfo p in pInfo)
   {
    string fmt = string.Format("{0} = {1}", p.Name, p.GetValue(this, null));

    sb.Append(fmt + "\r\n");
   }

   return sb.ToString();
  }

The code first gets the Type of the class that contains the properties. Then it retrieves an array of PropertyInfo objects that contains each property name and type. The GetValue method of the PropertyInfo class is used to retrieve the value of the property. It takes two arguments; the first argument is the pointer to the class that contains the property, and the second value is an object array in the case that the property is an indexed property (stores an indexed array). if the class does not contain any indexed properties, you can pass in null for the second parameter.

log4net setup for .NET 2.0

2006-08-15T16:37:00.000-07:00

For some reason, even though setting up log4net is relatively simple, I always spend too much time trying to configure it for various types of applications (Web, Console, Web Service, Windows Service, Windows App), and after I figure it out, I forget to document what I did to get it working. Here's an attempt to do this.

Console Apps:
First, you need to download log4net. You can get it from the log4net Downloads page.

Once you've installed it, add a reference to it from your project that will perform the logging. The location of the log4net.dll for 2.0 on my machine is at C:\log4net\log4net-1.2.10\bin\net\2.0\release

Add a section in the configSections area of the hosting applications' app.config or web.config file:


<section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler, log4net"/>

Add the log4net configuration settings to the app.config:


<log4net>
  <!-- RollingFileAppender looks after rolling over files by size or date -->
  <appender name="RollingFileAppender" type="log4net.Appender.RollingFileAppender">
    <param name="File" value="c:\\Logs\\RollingLogHelloWorld.log">
    <param name="AppendToFile" value="true">
    <param name="MaxSizeRollBackups" value="10">
    <param name="MaximumFileSize" value="1000">
    <param name="RollingStyle" value="Size">
    <param name="StaticLogFileName" value="true">
    <layout type="log4net.Layout.PatternLayout">
      <param name="ConversionPattern" value="%d [%t] %-5p %-45c [%x] - %m%n">
    </layout>
  </appender>
  <!-- FileAppender appends to a log and it is manually managed or size -->
  <appender name="FileAppender" type="log4net.Appender.FileAppender">
    <param name="File" value="c:\\Logs\\LogHelloWorld.log">
    <!-- Example using environment variables in params -->
    <!-- <param name="File" value="${TMP}\\ApplicationKit.log"> -->
    <param name="AppendToFile" value="true">
    <layout type="log4net.Layout.PatternLayout">
      <param name="ConversionPattern" value="%d [%t] %-5p %c [%x] - %m%n">
    </layout>
  </appender>
  <!-- Setup the root category, add the appenders and set the default level -->
  <root>
    <level value="INFO">
    <appender-ref ref="FileAppender"></appender-ref>
 </level>
</root>
</log4net>

This configures log4net to use one or more appenders, either a RollingFileAppender or a FileAppender. The <root> element defines which file appender it will use.

The log files are created in the c:\Logs directory. Make sure that the process that hosts the classes that perform the logging (classes contained either within the exe or within a class library dll) has write access to the directory where files are created. For windows and console applications the user identity is the current logged in user that executes the console application. For windows services, the user identity is the user that the service is configured to run as. For ASP.NET applications, give the ASPNET user access Full control rights to the webroot folder (the physical folder location for the virtual directory of the app) for the application. This will allow the aspnet_wp.exe process to create/write/update the log file

You can also add a switch that will output log4net's debug information to the Visual Studio output debug window as an appSetting:


<appsettings>
  <add key="log4net.Internal.Debug" value="true">
</add>
</appsettings>

If you have an AssemblyInfo.cs file in your project, you should add an entry to it which will configure the logging framework:


[assembly: log4net.Config.DOMConfigurator()]

Alternatively, you can put the initialization function into your code, you should execute the following line when the application first starts:


log4net.Config.XmlConfigurator.Configure();

In each class that will perform logging, add the following using statements:


using log4net;
using log4net.Config;

Add the following static member variable to each class, replacing <class name=""> with the name of the class:


private static readonly ILog log = LogManager.GetLogger(typeof (<class name="">));

when you want to log something, you can try this:


log.Info("Hello World.");

Good Read on writing maintainable code

2006-08-11T20:14:00.000-07:00

here

Network Sequence Diagrams

2006-08-11T19:25:00.000-07:00

I stumbled upon some HTTP and TCP sequence diagrams at the EventHelix site. They also have some interesting articles related to real time and embedded system design. You can find them here

Problems undeploying an assembly in BizTalk 2004

2006-08-01T14:48:00.000-07:00

If you ever get this error when undeploying a pipeline or schema assembly in BizTalk 2004:

Some items in the removed assembly are still being used by items not
defined in the same assembly, thus removal of the assembly failed.
Make sure that items in the assembly you are trying to remove fulfill the
following conditions:

1. Pipelines, maps, and schemas are not being used by Send Ports or Receive
Locations
2. Roles have no enlisted parties.

Try the following:

Don't forget to write down what the current settings are, once you've undeployed and redeployed the assemblies, you'll need to update the settings that you changed to their original values.

* Change the send ports send pipeline in the Visual Studio BizTalk Explorer (Edit | Configuration | Send | General) to reference the default Microsoft.BizTalk.DefaultPipelines.PassThru
* Remove all outbound maps that are associated with the send port in the Visual Studio BizTalk Explorer (Edit | Configuration | Filters & Maps | Outbound Maps)
* Check that your roles do not have enlisted parties.

doing these steps should allow you to undeploy the assemblies.

Visual Studio 2005 and ExpansionsXML.xml

2006-07-28T16:49:00.000-07:00

In Visual Studio 2005, I started to notice excessive disk activity when I saved one or more files. So, I installed File Monitor from Sysinternals and I noticed that when I saved my files, that the monitor reported that a lot of operations were performed on a file called ExpansionsXML.xml in the C:\Documents and Settings\\Local Settings\Application Data\Microsoft\VisualStudio\8.0\1033 directory. This file is used to store code snippets, and I wasn't able to find a way to turn off the code snippets, so I I googled around for a bit, and I found a news posting that addressed the problem. So the temporary fix is to make the ExpansionsXML.xml file read-only. I did that and no more disk thrashing.

CopySourceAsHtml

2006-07-01T14:01:00.000-07:00

There's a cool tool for Visual Studio 2005 that allows you to copy ans paste code as
HTML. Very usefull when copying/pasting from Visual Studio into a blog entry.

You can get it here

    7    public interface ISpecification

    8     {

    9        bool isSatisfiedBy(object candidate);

   10     }

   11 

   12     public class LogicalAnd : ISpecification

   13     {

   14         public bool isSatisfiedBy(object candidate)

   15         {

   16             throw new Exception("The method or operation is not implemented.");

   17         }

   18     }

How to become a hacker

2005-09-29T12:06:00.000-07:00

Nat Friedman has a great post on what it takes to become a decent programmer:

How to become a hacker

I agree with all of his points, especially the paragraph where he mentions that experienced programmers write easy to read code. I can agree with him since, I remember when I was first starting my career that I would try to come up with "elegant" solutions which in hindsight they were not elegant but they were more complex than what was needed to solve the problem. As I my skillset matured, I always tried to come up with a solution that is simple enough to solve the problem. I don't always succeed, but it is worth the effort, especially when you have to revisit your code months later and attempt to fix a bug, and you find a fairly simple to read codebase instead of a over designed mess of curly braces. Make the solution as simple as it needs to be but not more simple than that (or whatever Einstein said).

Dynamic Code Execution

2005-08-29T15:26:00.000-07:00

Both Eric Gunnerson and Joel Pobar have written about executing code dynamically:

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dncscol/html/csharp02172004.asp

http://msdn.microsoft.com/msdnmag/issues/05/07/Reflection/default.aspx

Investment Books

2005-08-24T16:24:00.000-07:00

Over at Deadprogrammer's Cafe he mentions a few books about the stock market/wall street that are good reads:

"A Random Walk Down Wall Street"

"Liar's Poker"

"Ugly Americans"

Testing a post from Word

2005-08-17T13:49:00.000-07:00

Testing a post from Word to Blogger:

abstract class  ProcessorWorker
     {
          protected string _url;
          protected static string _results;

          public ProcessorWorker()
          {

          }

          public virtual void Run()
          {
               Console.WriteLine(string.Format("Results: {0}", _results));
               Console.ReadLine();
          }
     }

Just a Test.

.NET XML Performance Tips

2005-08-10T14:19:00.000-07:00

A link that offers some tips on using XML in .NET

http://msdn.microsoft.com/library/en-us/dnpag/html/scalenetchapt09.asp

Interview with Erich Gamma

2005-08-10T13:55:00.000-07:00

Here he discusses design patterns and tips on becoming a better designer.

http://www.artima.com/lejava/articles/patterns_practice.html

Math.Round in .NET

2005-07-18T16:29:00.000-07:00

The .NET 1.1 Framework Math.Round function uses an interesting rounding algorithm called "Bankers Rounding". Basically, this means that the numbers are rounded to the nearest even number. So both 5.3 and 5.6 are rounded to the nearest even number, 6. This is different from the rounding algorithm that we applied in elementary school, which is to round up any number that has a fractional element greater than or equal to .50. I'm not sure why they did the rounding this way, but we have to live with it. I did a sample run of some numbers and saw the following when I used Math.Round():

using Math.Round(numbers[i])
====================
774.10 rounded : 774
774.50 rounded : 774
774.99 rounded : 775
775.10 rounded : 775
775.50 rounded : 776
775.99 rounded : 776
775.15 rounded : 775
775.55 rounded : 776

As you can see, 774.50 was rounded to 774 (the nearest whole even number to 774.50).

Apparently, the string.Format() method actually rounds numbers the normal way, as you can tell from this run:

using string.Format("{0:n0}", numbers[i])
=========================================
774.10 rounded : 774
774.50 rounded : 775
774.99 rounded : 775
775.10 rounded : 775
775.50 rounded : 776
775.99 rounded : 776
775.15 rounded : 775
775.55 rounded : 776

Here, all of the numbers with fractional values less than .50 are rounded down to the nearest whole number, while numbers with fractional values greater than .50 are rounded up to the nearest whole number.

Version 2.0 of the framework will provide the ability to specify the type of rounding algorithm to use with the Math.Round() method.

Microsoft Connected Systems Kit

2005-05-05T10:29:00.000-07:00

I was a member of the team that helped write Microsoft's Connected Systems Kit. I focused on the BizTalk components. Check it out here Connected Systems Kit

URL Rewriting

2005-03-17T17:41:00.000-08:00

You can redirect users to a URL by using URL Rewriting in ASP.NET. To accomplish this, you can use a HttpModule that Scott Mitchell wrote to perform the redirects based on mapping rules configured in web.config for the web application. His article on this is here: URL Rewriting with ASP.NET

One thing that you might want to do is to allow users to navigate your site by using directory-only URL's like this: http://localhost/Products, which should redirect them to the http://localhost/Products/inventory.aspx page. IIS processes requests for directory-only URLs by first determining if the directory exists, and if it does, it then checks to see if the directory contains a default document. By default, the following files are default documents for directories: default.htm, default.asp, index.htm and iisstart.asp. If the directory does not contain one of the default files, IIS will issue a 403 Forbidden error. To require IIS to process the directory request for a directory that only contains the default.aspx file, you will need to add the default.aspx document to the default documents property via the property page for the virtual directory. Once this is done, you can add a rule to redirect /Products/default.aspx to /Products/inventory.aspx as described in Scott's article.

Variable scope and Debug vs. Release builds

2005-03-17T17:01:00.000-08:00

Lately, I was debugging some code when I came across this little gem in global.asax.cs:


protected void Application_Start(Object sender, EventArgs e)
{
  StartTimer();
}

public void StartTimer()
{
  string METHODNAME = "StartTimer";
  
  try
  {
    TimerCallback tcallback = new TimerCallback(TimerMethod);
   
    Timer timer = new Timer(tcallback, null, new TimeSpan(0, 0, 1), new TimeSpan(0, 0, 10));
  }
  catch (Exception ex)
  {
    System.Diagnostics.Debug(ex.Message);   
  }
}

The code basically starts a timer when the web application starts (when the first web page request is issued by a client). The timer fired fine during debugging, but when I ran the web app without debugging, the timer didn't fire. I did fix the issue by scoping the timer object at the Global class level, rather than as a local variable within the StartTimer() mehtod (the timer object was only visible in StartTimer), but I wanted to find out why the debug build exhibited different behavior from the Release build. I stumbled across Mike Tautly's weblog On Garbage Collection, Scope and Object Lifetimes and he describes one reason for the issue: The JIT optimization will determine how long local variables are kept around before being garbage collected.

This page provides a good introduction to Page-User Control communication

2005-03-14T15:33:00.000-08:00

http://www.openmymind.net/communication/index.html

Differences between Type.GetType() and typeof

2005-03-11T11:38:00.000-08:00

Suzanne Cook has a good explanation for why GetType() only searches the current assembly in addition to mscorlib.dll when it tries to find a type.

http://blogs.msdn.com/suzcook/archive/2003/05/30/57158.aspx

You can use typeof() which will search all loaded assemblies within the current app domain.

"The dependency whatever.dll cannot be copied to the run directory because it would conflict with the dependancy..."

2005-03-04T11:25:00.000-08:00

If you ever get a message along the lines of:

Warning: The dependency 'Foo, Version=1.0.1661.21305, Culture=neutral' in project 'Bar' cannot be copied to the run directory because it would overwrite the reference 'Foo, Version=1.0.1661.20048, Culture=neutral'

You can check out Scott Hanselman's site here for some tips:

Dependency Conflicts

In addition, you can also check the dependency list using ILDASM. If you open each dependent DLL in ILDASM and inspect the manifest, looking for references to 'Foo', you should be able to track down the assembly that is referencing the old assembly (in this case the 1.0.1661.20048 version of Foo). Usually the assembly is referencing a different version of the conflicting DLL (or the assembly is referencing multiple versions of the same DLL). Once you find the assembly, you can rebuild it or delete it from the bin directory and re-reference it.

Programatically POST xml to a page

2005-03-02T14:48:00.000-08:00

In .NET you can use the HttpWebRequest class to make page requests. The HttpWebRequest class supports the GET and POST verbs. Suppose that you wanted to retrieve xml from a page by issuing a GET request for the page http://localhost/Test/Default.aspx?Name=Test&Email=Test. You could do this with the following code:


string uriString = "http://localhost/Test/Default.aspx?Name=Test&Email=Test";
HttpWebRequest httpRequest = null;
HttpWebResponse response = null;

string xml = "";
Uri uri = new Uri(uriString);
httpRequest = (HttpWebRequest)WebRequest.Create(uri);
response = (HttpWebResponse)request.GetResponse( );

if (response != null)
{
  Stream responseStream = response.GetResponseStream( );
  StreamReader reader = new StreamReader(responseStream, Encoding.UTF8);

  try
  {
    xml = reader.ReadToEnd( );
  }
  finally
  {
    reader.Close( );
  }
}

This will return the xml string into the xml variable.

Now suppose that you wanted to POST xml to the same web page. You can either post the xml directly to the page, or you could put the xml into a form variable and post it to the page. To post the xml as part of the form (in the 'BodyText' variable), you could do this:


XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load("test.xml");
body = xmlDoc.OuterXml;

string uriString = "http://localhost/Test/Default.aspx?Name=Test&Email=Test";
HttpWebRequest httpRequest = null;
HttpWebResponse response = null;

string xml = "";
Uri uri = new Uri(uriString);
httpRequest = (HttpWebRequest)WebRequest.Create(uri);

httpRequest.Method = "POST";
postData = HttpUtility.HtmlEncode(postData);
postData = HttpUtility.UrlEncode(postData);
postData = "BodyText=" + postData;
ASCIIEncoding encoding = new ASCIIEncoding();
byte[] bytes = encoding.GetBytes(postData); 
httpRequest.ContentLength = postData.Length;
httpRequest.KeepAlive = false;
httpRequest.ContentType = "application/x-www-form-urlencoded";
Stream requestStream = httpRequest.GetRequestStream( );
requestStream.Write(bytes,0,bytes.Length);
requestStream.Close( );
response = (HttpWebResponse)request.GetResponse( );

if (response != null)
{
  Stream responseStream = response.GetResponseStream( );
  StreamReader reader = new StreamReader(responseStream, Encoding.UTF8);

  try
  {
    xml = reader.ReadToEnd( );
  }
  finally
  {
    reader.Close( );
  }
}

Be careful to not confuse HtmlEncode and UrlEncode. It seems that even though the content type is set to "application/x-www-form-urlencoded" that you should NOT JUST URL encode the xml string. The HttpWebRequest object will appear to process the message for some characters if the string is UrlEncoded, but for other characters, you will receive a '(500) Internal Server' error (this case is especially for xml strings that contain the < character). You should first HtmlEncode, then UrlEncode the string, then prefix the form variable. On the server side, you only have to HtmlDecode the string since the UrlDecoding is automatically done for you.

2005-02-28T15:28:00.000-08:00

If you have an object that you would like to serialize into xml as a string, you can do the following:


// returns a utf-16 string
XmlSerializer ser = new XmlSerializer(test.GetType());
StringWriter sw = new StringWriter();
ser.Serialize(sw, test);
ret = sw.ToString();

If you want to use the above code to return a utf-8 encoded string, you cannot because the StringWriter class does not allow you to set the encoding, the Encoding property is read-only. You might be able to use the XmlTextWriter to serialize the object in utf-8 encoding. One of the overloaded constructors takes a TextWriter as an argument, so I thought that I could create the XmlTextWriter, pass in the StringWriter (which derives from TextWriter), and then set the Encoding property on the constructed XmlTextWriter object. Unfortunately, an Encoding property does not exist on the XmlTextWriter object. The XmlTextWriter has two other constructors, one that takes a Stream and one that takes a filename. Both of the constructors also take an Encoding object as a parameter. Since I do not want to write to a file (I want to write to a string), I will use the constructor that takes a Stream, and pass in a MemoryStream object:


// returns a utf-8 string with a prepended character
MemoryStream memStrmWrite = new MemoryStream();
XmlSerializer ser = new XmlSerializer(test.GetType());
XmlTextWriter xtw = new XmlTextWriter(memStrmWrite, Encoding.UTF8);
ser.Serialize(xtw, test);
memStrmWrite = (MemoryStream)xtw.BaseStream;
UTF8Encoding enc = new UTF8Encoding();
ret = enc.GetString(memStrmWrite.ToArray());

This does return the xml in the correct encoding, but it also prepends the xml with an byte order mark character (which most XML 1.0+ processors should handle):


?<?xml version="1.0" encoding="utf-8"?>....

To get the proper encoded string without the leading extra character, read from the MemoryStream into a StreamReader, and call the StreamReader.ReadToEnd() method, remembering to reset the position of the MemoryStream to zero after the Serialize() method is executed:


MemoryStream memStrmWrite = new MemoryStream();
XmlSerializer ser = new XmlSerializer(test.GetType());
XmlTextWriter xtw = new XmlTextWriter(memStrmWrite, Encoding.UTF8);
ser.Serialize(xtw, test);
memStrmWrite = (MemoryStream)xtw.BaseStream;

// Keeps the byte order mark intact
if (_bKeepByteOrderMark == true)
{
   UTF8Encoding enc = new UTF8Encoding();
   ret = enc.GetString(memStrmWrite.ToArray());
}
else
{
   memStrmWrite.Position = 0;  // reset the position to 0
   StreamReader sr = new StreamReader(memStrmWrite, Encoding.UTF8);
   ret = sr.ReadToEnd();
}

This will remove the byte order mark at the beginning of the xml:


<?xml version="1.0" encoding="utf-8"?>....

Here are a few links on this:

http://www.eggheadcafe.com/articles/system.xml.xmlserialization.asp

http://weblogs.asp.net/rmclaws/archive/2003/07/31/22080.aspx

http://msdn.microsoft.com/msdnmag/issues/01/05/xml/

ASP.NET, IIS6 and SQL Server 2000

2005-01-06T16:40:00.000-08:00

If you are trying to connect to SQL server using a SQL login/password in the connection string, and you receive the following error:

Login failed for user ''. Reason: Not associated with a trusted SQL Server connection.

Do the following:

Check the security settings on the SQL Server registration. Right click the server (local), choose the security tab and make sure that the 'SQL Server and Windows' radio button is selected. If it is not, select it, then restart SQL Server.
If that doesn't work, check if ASP.NET is doing any kind of impersonation by looking for an impersonation tag in web.config. If the authentication tag is set to "Windows" and the impersonation tag is set to "true", then ASP.NET will impersonate the logged in user, which is the user that IIS authenticated (If IIS is set to use Windows authentication). So If my user is DOMAIN\USER, IIS would first perform authentication and then forward the request as well as my security token to the ASP.NET process. If the authentication tag is "Windows" and the impersonation tag is "true", the ASP.NET process will impersonate the logged in user (DOMAIN\USER). Any requests (file, network, database) from the ASP.NET process will operate under the identity of this logged in user. If impersonation is not set to true, and IIS authntication is set to anonymous, the ASP.NET process will run as ASPNET for IIS5 or the application pool identity, NT Authority\NetworkService for IIS6.

More information can be found here

Scolbe's nice summary of using the web as a tool

2004-10-08T16:15:00.000-07:00

awesome summary by Scoble about how people will use the web:
http://radio.weblogs.com/0001011/2004/10/07.html#a8370

BizTalk 2004 Contest Winners

2004-09-16T14:07:00.000-07:00

Scott Woodgate has the list of the BizTalk 2004 developers content winners here:

http://blogs.msdn.com/scottwoo/archive/2004/09/14/229601.aspx

2004-09-14T14:03:00.000-07:00

Control Events

Controls can have events that are associated with them. Suppose that we had a server control that contained a single button. The button click event could perform some processing directly, or the event could call a function in another client via an exposed public event. If we have a number of different pages that contain the server control on them, each page could hook a function to the event defined in the button. When the button click event is fired, the hook function on the page is called. The page can now determine what happens in response to a click event that occurred on the button within an embedded server control. It is the page's responsibility to wire the button click event to the hook function. Note that the server control (or the button within the control) has no knowledge of what client is consuming it. Each page within the application can determine the behavior of the control event via the exposed hook function on the page. Suppose we had the following in the ascx file for the control:

<table width="100%">
<TR>
<td align="right">
<asp:Button id="btnProceed" runat="server" Text="Proceed"></asp:Button>
</td>
<td align="left">
<asp:Button id="btnCancel" runat="server" Text="Cancel"></asp:Button>
</td>
</TR>
</table>

In the code behind for the control we would define two EventHandlers, one for each button:

public event EventHandler Proceed;
public event EventHandler Cancel;

The button events would then forward to the hook method associated with the Proceed, or Cancel event objects.

private void btnProceed_Click(object sender, System.EventArgs e)
{
Proceed(this, e);
}

private void btnCancel_Click(object sender, System.EventArgs e)
{
Cancel(this, e);
}

The page that contains the control, sets the OnProceed and OnCancel events on the control to the hook functions in the code-behind of the page:

<%@ Register TagPrefix="ctrl" TagName="Buttons" Src="Buttons.ascx" %>

...

<ctrl:buttons id="NavigateButtons" runat="server" OnProceed="Page_Proceed" OnCancel="Page_Cancel"></ctrl:buttons>

The code behind of the page contains the hook functions Page_Proceed and Page_Cancel. Note that the hook functions are protected. The generated class that derives from the code behind will need to access the two hook functions, so they are declared with protected visibility.

protected void Page_Proceed(object sender, System.EventArgs e)
{
// do something for proceed
}

protected void Page_Cancel(object sender, System.EventArgs e)
{
// do something for cancel
}

When the aspx page is parsed and the dynamic class is generated, the control properties OnProceed and OnCancel are translated into the following code (in the generated page class):

NavigateButtons.Proceed += new EventHandler(this.Page_Proceed);
NavigateButtons.Cancel += new EventHandler(this.Page_Cancel);

When the Button1_Click event in the control fires, the Page_Proceed method is called in the page. Each page can now define hook methods that should be called when the button click events on the contained control are fired. Each page defines the hook functions, and the control tag in the .aspx page is modified to associate the hook methods with events in the control:

Add the EventHandler declarations in the control
Add the hook functions in the parent page that should be called when the event in the control is triggered
Add the server control tag to the .aspx file associated with the page
Add the On... attributes to the server control tag and set the attributes to the appropriate hook function in the page. Make sure that the attribute is named the same as the declared event in the control, prefixed by On. So if the event field in the control is Proceed, the attribute on the control in the .aspx page should be in the format OnProceed="hook function name in page"

Now each page can define their own hook functions for the Proceed and Cancel events exposed by the control:

// page A
<ctrl:buttons id="NavigateButtons" runat="server" OnProceed="PageA_Proceed" OnCancel="PageA_Cancel"></ctrl:buttons>

// page B
<ctrl:buttons id="NavigateButtons" runat="server" OnProceed="PageB_Proceed" OnCancel="PageB_Cancel"></ctrl:buttons>

The functions within each page (PageA_Proceed, PageB_Proceed) do not have to be named uniquely. Both pages could contain a Page_Proceed and Page_Cancel hook functions, the only difference being that the Page_Proceed and Page_Cancel in each page would perform different operations.

2004-09-14T13:59:00.000-07:00

XmlDocument: Provides direct memory access to the entire xml document. Nodes can be selected from the XmlDocument by XPath expressions. Can use a large amount of memory resources.
XMLTextReader: Provide forward-only access to an xml stream. The entire xml dataset is not loaded into memory all at once, the XmlTextReader reads in nodes on an as-needed basis. The XMLTextWriter writes xml data to a file in a forward-only manner.
XPathNavigator: Provides bi-directional access to nodes in a XmlDocument or XPathDocument. The XPathDocument provides a fast read-only cache for an xml document. If you are using an XmlTextReader to access the xml, an XPathDocument can be created by passing in a XmlTextReader object into the XPathDocument constructor. This object is not created directly, it is returned from a call to the CreateNavigator() method on the XmlDocument/XPathDocument class.

When inserting text into an XML file, beware of the special characters <, >, ', ", &. They should be escaped by using the special notation.

When passing XML data in memory you can use the following object types:

XmlNode. Provides an interface to an in-memory tree representation of an XML document. Gives a R/W interface to the XML data structure in addition to XPath expression selections. The XmlDocument inherits the XmlNode abstract class.
XmlReader. Streaming forward only object. Provides an xml facade over an existing object graph/text/binary data object. Difficult to use.
XPathNavigator. Traverses xml in a bi-directional manner. Able to navigate an xml document via XPath expressions. This is the preferred way to pass xml around in the CLR.

2004-09-14T13:47:00.000-07:00

Delegates

Delegates are data types in the .NET framework that reference a method with a specific signature. Delegates are used to execute a method on a class via the created type. The ThreadStart type is an example of a delegate, in this case the ThreadStart delegate references a method that has an empty parameter list. You can create a ThreadStart delegate as follows:

  ThreadStart ts = new ThreadStart(DelegateFunction);
  Thread t = new Thread(ts);
  t.Start(); //start the thread

  for (int i = 0; i < 1000; i++)
   t.Sleep(5);



The ThreadStart class takes a reference to a method that cannot have any input parameters. The DelegateFunction is defined as:

  public void DelegateFunction()
  {
   // Do something...
  }


The DelegateFunction is executed when the Thread.Start function is run. In this case, the ThreadStart delegate wraps the method call, so that the method can be called via a type instance. Delegates are used for callback functions, events and as an implicit interface contract. A delegate can reference a function that takes parameters:

public delegate string FunctionPointer(int foo, string bar);

public FunctionPointer fpi;
fpi = new FunctionPointer(Function);

The Function declaration loooks like this:

string Function(int foo, string bar)
{
  string temp = "";

  for (int i = 0; i < foo; i++)
   temp += bar;

  return temp;
}
The same delegate can point to another function with the same signature

string AnotherFunction(int foo, string bar)
{
  string temp = "AnotherFunction";

  for (int i = 0; i < foo; i++)
   temp += bar;

  return temp;
}

The following is a sample console application that demonstrates delegates. In Main(), the source class and each sink class is created. The source class is the class that will call the function in the sink class via the delegate reference. Each sink class contains a method called Callback that will be called by the source class. To hook up the Callback method in the sink class to the delegate in the source class, a reference to the delegate is created and the name of the callback function in the sink class is passed as a parameter to the delegate reference constructor:

using System;

namespace Delegate
{
  class Class1
  {
   [STAThread]
   static void Main(string[] args)
   {
    SourceClass sc = new SourceClass();
    SinkAClass sac = new SinkAClass();
    SinkBClass sbc = new SinkBClass();

    // Hook up the function and execute
    sc.fp = new SourceClass.FunctionPointer(sac.Callback);
    sc.DoSomething();

    // Hook up a new sink
    sc.fp = new SourceClass.FunctionPointer(sbc.Callback);
    sc.DoSomething();
   }
  }

  public class SourceClass
  {
   public delegate void FunctionPointer(int arg1, string arg2);
   public FunctionPointer fp;

   public void DoSomething()
   {
    // call the function pointed to by fp;
    fp(3, this.ToString());
   }
  }

  public class SinkAClass
  {
   public void Callback(int arg1, string arg2)
   {
    Console.WriteLine("{0} Callback method was called with arguments: {1}, {2}", this.ToString(), arg1.ToString(), arg2);
   }
  }

  public class SinkBClass
  {
   public void Callback(int arg1, string arg2)
   {
    Console.WriteLine("{0} Callback method was called with arguments: {1}, {2}", this.ToString(), arg1.ToString(), arg2);
   }
  }
}

In new york

2004-07-29T10:30:00.000-07:00

In new York

Trying to get to London...

2004-07-24T07:39:00.000-07:00

So my JetBlue flight from Oakland to NY was cancelled due to weather.
So, day one of my vacation will be spent haggling with agents at
airport ticket counters. I was also planning to visit Paris, but I have no time
for that now.

I was in total shock when I arrived at the airport and found out that my flight was cancelled. There were two later JetBlue flights to NY, but they were delayed. The JetBlue person was nice enough to try to find me a JetBlue flight that would get me to NY in time for my flight to London, but every flight was sold out. So I sat and waited for the JetBlue agent to find me another flight for 3 hours while people around me checked in their bags going to NY. He called my other airline and tried to see if they would change my reservation, but they said that I would either have to fly standby, or pay $1500 for a ticket. So I agreed to go standby to London, and the JetBlue agent refunded my ticket, and purchased another ticket for me on another airline.

Summary of WS-* Specifications

2004-07-10T10:41:00.000-07:00

From the BEA site: WS Security

"

Web Services Security Specifications

WS-Security describes how to attach signature and encryption headers to SOAP messages. In addition, it describes how to attach security tokens, including binary security tokens such as X.509 certificates and Kerberos tickets, to messages.
WS-Policy represents a set of specifications that describe the capabilities and constraints of the security (and other business) policies on intermediaries and endpoints (e.g. required security tokens, supported encryption algorithms, privacy rules) and how to associate policies with services and endpoints.
WS-Trust describes a framework for trust models that enables Web services to securely interoperate by requesting, issuing, and exchanging security tokens.
WS-Privacy will describe a model for how Web services and requestors state privacy preferences and organizational privacy practice statements.
WS-SecureConversation describes how to manage and authenticate message exchanges between parties, including security context exchanges and establishing and deriving session keys.
WS-Federation describes how to manage and broker the trust relationships in a heterogeneous federated environment, including support for federated identities, sharing of attributes, and management of pseudonyms.
WS-Authorization will describe how to manage authorization data and authorization policies.

Additionally, several other key Web services specifications complete the foundation layer of specifications:

WS-Addressing describes how to specify identification and addressing information for messages.
WS-MetadataExchange describes how to exchange metadata such as WS-Policy information and WSDL between services and endpoints.
WS-ReliableMessaging describes how to ensure reliable delivery of messages in the presence of unreliable networks.
WS-Transactions and WS-Coordination describe how to enable transacted operations as part of Web service message exchanges.

The combination of the specifications above and interoperability profiles will enable customers to easily build interoperable secure reliable transacted Web services that integrate within and across federations by composing federation and security specifications with other Web services specifications. "

Retrieving the identity associated with the current Thread

2004-07-07T15:06:00.000-07:00

Using the System.Threading and System.Security.Principal namespaces, you can obtain the identity of the user associated with the current thread:


AppDomain.CurrentDomain.SetPrincipalPolicy(PrincipalPolicy.WindowsPrincipal);



IPrincipal wp = Thread.CurrentPrincipal;

IIdentity id = wp.Identity;



string authType = id.AuthenticationType;

string isAuth = id.IsAuthenticated.ToString();

string name = id.Name;

Web Service Security

2004-06-30T15:54:00.000-07:00

Using the WS-Security you can make your web service communications more secure by using encryption, signing in addition to authentication and authorization. SOAP Header items can be encrypted using Username (user, passoword), Keberos or X.509 certificates. Electronic signatures are created using X.509 or Username tokens.

First, a few definitions:

Use encryption to encode messages sent between the web service client and the web service server. In the case of a SOAP message, the SOAP body is usually encrypted using a public key (a subset of the private key located on the server) that is located on the client computer. The message body is encrypted using this key, and it is sent to the server. The server uses a private key to decode the message. Messages can use Username tokens or X.509 certificates for encryption. In the case of the Username token encryption, the Username token is used to encrypt the Soap body of the message on the client, and the Username token is also sent to the server in the Soap header. Once the server receives the message, the server uses the Username token sent in the header to decrypt the body of the message. With X.509 certificates, the server uses a private key assigned to it to extract a corresponding public key. The public key is then used by clients of the web service to encrypt messages sent to the server. Once the server receives the message, it uses the private key to decrypt the Soap body of the message. Since X.509 certficiates are used for encryption and not authorization, a Username token (Kerberos token) are still required for authentication and authorization. In addition to encrypting the body of the message, the Soap header can be encrypted as well. The entire header can be encrypted (including the username token) using an X.509 certificate.

Use digital signing to mark the message with a unique identifier. The identifier is usually generated using an X.509 certificate, but a simple Username token can be used to generate a signature. The signature can be used by the web service to determine the identity of the message sender. Sending a signature instead of a username & password combination is preferred since no passwords are sent between the client and the web service. The authentication is based solely on the signature, since the signature was generated using partial information from a certificate on the web service server. The public key that a client uses to generate the signature is a portion of the private key present on the web server. If a message is received by a web service that requires signed messages, the web service might decide that the message has been tampered with and will not process the message.

Username, and Keberos tokens can be used for authentication. The credentials are set by the client and read by the web service. When using Username tokens, passwords can be sent in either plain text or as hashes (digest). It is up to the web service to determine what type of tokens it will use, and the client must send compatible tokens to the server. The server can create policies which dictate what type of tokens are valid for authentication.

Username tokens can also be used for authorization. If a client sends a username token to a web service, the web service will unencrypt the token and pass the token to the OS for authentication. If the authentication fails, an error is returned to the client. If the authentication succeeds, the WSE framework will check to see if the authenticated username token is authorized to access the requested resource (the web method the client is attempting to execute). If the token is not authorized access, an error is returned to the client. If the token is authorized access to the resource, the requested web method is executed and the results are returned to the client.

Authorization can be implemented in two ways:
1. Use WS-Policy to setup policies that are required by the web service. Each web service (.asmx) can be associated with one or more policies. A policy can be setup to allow only users in the Domain\Group access to the web methods exposed by the web service. To authorize access to the web methods in the web service, the WSE framework will first try to authenticate via the username token, and then it will determine if the role defined in the policy (in policyConfig.Cache) is in the list of roles associated with the username token.
2. Programmatically send Username tokens to the web service. The client would create a UsernameToken object from the user credentials and add the token to the RequestSoapContext.Security.Tokens collection. The web server would then read the UsernameToken and authenticate the token. Once the token was authenticated, the web service could determine if the roles in the token include the required role defined in the web service and if so, authorize access to the requested resource. You could also intercept the authentication process by deriving a class from UsernameTokenManager and overriding the AuthenticateToken() method to look up the roles (in a DB) associated with the user in the token and add those roles to the principal associated with the token. The web service would then retrieve the token from the SoapContext.Security.Tokens collection and compare the required role to execute the web service with the role list from the token.

Usage	Username	X.509	Kerberos
Signing	Y	Y	N
Encryption	Y	Y	N
Authentication	Y	N	Y
Authorization	Y	N	Y

Control Events

2004-06-24T12:40:00.000-07:00

In the code behind for the control we would define two EventHandlers, one for each button:


  public event EventHandler Proceed;

  public event EventHandler Cancel;

The button events would then forward to the hook method associated with the Proceed, or Cancel event objects.


  private void btnProceed_Click(object sender, System.EventArgs e)

  {

   Proceed(this, e);

  }

  

  private void btnCancel_Click(object sender, System.EventArgs e)

  {

   Cancel(this, e);

  }

The page that contains the control, sets the OnProceed and OnCancel events on the control to the hook functions in the code-behind of the page:


  <%@ Register TagPrefix="ctrl" TagName="Buttons" Src="Buttons.ascx" %>

  

  ...

The code behind of the page contains the hook functions Page_Proceed and Page_Cancel. Note that the hook functions are protected. The generated class that derives from the code behind will need to access the two hook functions, so they are declared with protected visibility.


  protected void Page_Proceed(object sender, System.EventArgs e)

  {

   // do something for proceed

  }

  

  protected void Page_Cancel(object sender, System.EventArgs e)

  {

   // do something for cancel

  }

When the aspx page is parsed and the dynamic class is generated, the control properties OnProceed and OnCancel are translated into the following code (in the generated page class):


  NavigateButtons.Proceed += new EventHandler(this.Page_Proceed);

  NavigateButtons.Cancel += new EventHandler(this.Page_Cancel);

When the Button1_Click event in the control fires, the Page_Proceed method is called in the page. Each page can now define hook methods that should be called when the button click events on the contained control are fired. Each page defines the hook functions, and the control tag in the .aspx page is modified to associate the hook methods with events in the control:

* Add the EventHandler declarations in the control
* Add the hook functions in the parent page that should be called when the event in the control is triggered
* Add the server control tag to the .aspx file associated with the page
* Add the On... attributes to the server control tag and set the attributes to the appropriate hook function in the page. Make sure that the attribute is named the same as the declared event in the control, prefixed by On. So if the event field in the control is Proceed, the attribute on the control in the .aspx page should be in the format OnProceed="hook function name in page"

Now each page can define their own hook functions for the Proceed and Cancel events exposed by the control:


  // page A

  

  

  // page B

The functions within each page (PageA_Proceed, PageB_Proceed) do not have to be named uniquely. Both pages could contain a Page_Proceed and Page_Cancel hook functions, the only difference being that the Page_Proceed and Page_Cancel in each page would perform different operations.

Control Validation (brief)

2004-06-24T12:38:00.000-07:00

Let's say that we have the following simple page with one embedded server control (button) on the aspx page the following is the order of events that happen when the page is initially displayed:

1. The child controls' OnInit event is fired
2. The page OnInit event is fired
3. The Page's TrackViewState() is executed
4. The Page's OnLoad (Page_Load) event is fired
5. The child controls' OnLoad (Page_Load) event is fired
6. The Page's OnPreRender event is fired
7. The Page's SaveViewState() is run
8. The Page's SaveViewState() is run

If we have a click event defined for the button, called btn1_click, and inside this click event it executes a callback function called Page_Proceed on the page via postback, the order is:

1. The child controls' OnInit event is fired
2. The page OnInit event is fired
3. The Page's TrackViewState() is executed
4. The Page's OnLoad (Page_Load) event is fired
5. The child controls' OnLoad (Page_Load) event is fired
6. The Page's RaisePostBackEvent is fired
7. The child controls' btn1_Click event is fired
8. The Page's Page_Proceed() method is executed
9. The Page's OnPreRender event is fired
10. The Page's SaveViewState() is run
11. The Page's SaveViewState() is run

A few new events are added to the sequence: RaisePostBackEvent, btn1_Click, and the Page_Proceed event. The RaisePostBackEvent is used to trigger a server side event. The RaisePostBackEvent is defined as:

protected override void RaisePostBackEvent(IPostBackEventHandler sourceControl, string eventArgument)

RaisePostBackEvent takes two arguments: the IPostBackEventHandler derived control that is raising the event and a string argument. The RaisePostBackEvent will determine which function in the codebehind of the control to execute. If a textbox and a RangeValidator control are placed on the page, the following order is observerd (if the validation was successful):

1. The child controls' OnInit event is fired
2. The page OnInit event is fired
3. The Page's TrackViewState() is executed
4. The Page's OnLoad (Page_Load) event is fired
5. The child controls' OnLoad (Page_Load) event is fired
6. The Page's RaisePostBackEvent is fired
7. The Page's Validate() is fired
8. The child controls' btn1_Click event is fired
9. The Page's Page_Proceed() method is executed
10. The Page's RaisePostBackEvent finishes
11. The Page's OnPreRender event is fired
12. The Page's SaveViewState() is run
13. The Page's SaveViewState() is run

If the validation was not successful, no postback is processed, as all of the validation occurs on the client. One thing to note is that the fired event plus the Validate() methods are executed within the context of the RaisePostBackEvent. Usually a page processes only one event, so the RaisePostBackEvent waits until the fired event and its Validate() function to run before exiting. If the Validate() method of the Page fails, the fired event does not run. If we take a view of the source for the page in the browser, we see:

This basically calls the javascript function Page_ClientValidate(), which is located in /aspnet_client/system_web/1_1_4322/WebUIValidation.js:


  function Page_ClientValidate()

  {

   var i;

   for (i = 0; i < Page_Validators.length; i++) {

   ValidatorValidate(Page_Validators[i]);

   }

   ValidatorUpdateIsValid();

   ValidationSummaryOnSubmit();

   Page_BlockSubmit = !Page_IsValid;

   return Page_IsValid;

  }

This function iterates over each validator and calls the ValidatorValidate() function for each validator. Depending on the type of validator (RequiredField, RequiredRange, RegularExpression, etc.) a corresponding function exists in WebUIValidation.js:

* CompareValidatorEvaluateIsValid
* CustomValidatorEvaluateIsValid
* RegularExpressionValidatorEvaluateIsValid
* RequiredFieldValidatorEvaluateIsValid
* RangeValidatorEvaluateIsValid

The ValidatorValidate() uses the evaluationfunction property of each validator to execute one of the functions above:


 function ValidatorValidate(val)

 {

  val.isvalid = true;

  if (val.enabled != false) {

  if (typeof(val.evaluationfunction) == "function") {

  val.isvalid = val.evaluationfunction(val);

  }

  }

  ValidatorUpdateDisplay(val);

 }

Once evaluationfunction has run the isvalid field on each validator has been set. The ValidatorUpdateDisplay() function then runs. This function will then display the item within the span tag that is associated with the validator:

The ValidatorUpdateDisplay() will toggle whether the item within the 'span' tag is set to the 'hidden' or 'visible' state.


 function ValidatorUpdateDisplay(val)

 {

  if (typeof(val.display) == "string") {

  if (val.display == "None") {

  return;

  }

  if (val.display == "Dynamic") {

  val.style.display = val.isvalid ? "none" : "inline";

  return;

  }

  }

  val.style.visibility = val.isvalid ? "hidden" : "visible";

 }

If the validation succeeds, the item within the span tag remains hidden, otherwise it is visible.

Creating an XML driven web site

2004-06-24T12:35:00.000-07:00


  public void GetContent(string loc)

  {

   XmlTextReader reader = null;

   

   try

   {

    reader = new XmlTextReader(Server.MapPath(loc));

    

    if (reader != null)

     RenderContent(reader);

   }

   catch(Exception e)

   {

    string err = e.ToString();

   }

  }

The nodes in an XML stream can be accessed by an XMLDocument, an XMLTextReader/XMLTextWriter and an XPathNavigator. Each method has its advantages and drawbacks:

* XmlDocument: Provides direct memory access to the entire xml document. Nodes can be selected from the XmlDocument by XPath expressions. Can use a large amount of memory resources.
* XMLTextReader: Provide forward-only access to an xml stream. The entire xml dataset is not loaded into memory all at once, the XmlTextReader reads in nodes on an as-needed basis. The XMLTextWriter writes xml data to a file in a forward-only manner.
* XPathNavigator: Provides bi-directional access to nodes in a XmlDocument or XPathDocument. The XPathDocument provides a fast read-only cache for an xml document. If you are using an XmlTextReader to access the xml, an XPathDocument can be created by passing in a XmlTextReader object into the XPathDocument constructor. This object is not created directly, it is returned from a call to the CreateNavigator() method on the XmlDocument/XPathDocument class.

When inserting text into an XML file, beware of the special characters <, >, ', ", &. They should be escaped by using the special notation.

When passing XML data in memory you can use the following object types:

* XmlNode. Provides an interface to an in-memory tree representation of an XML document. Gives a R/W interface to the XML data structure in addition to XPath expression selections. The XmlDocument inherits the XmlNode abstract class.
* XmlReader. Streaming forward only object. Provides an xml facade over an existing object graph/text/binary data object. Difficult to use.
* XPathNavigator. Traverses xml in a bi-directional manner. Able to navigate an xml document via XPath expressions. This is the preferred way to pass xml around in the CLR.

Building Web Services Today (like, right now!)

2004-06-24T12:23:00.000-07:00

Rich Turner from the Indigo team has a post about creating web services using existing technologies:
Building Service Today.

In general, he has a few points:

“avoid the network wherever possible“.

you have choices: asmx, remoting, queuing, Enterprise Services

Use the facade pattern to abstract the service layer from the underlying business layer. Also use the facade pattern to abstract the Enterprise Services classes (if any) from the Business layer.

Think about transactions, either at the web service level or at the Enterprise Services level (if the transaction spans several business components)

Web Services exposing internal object types

2004-06-22T14:26:00.000-07:00

Lately I have been looking at creating some WSDL for a few web services for the product that I am working on.
One of the issues that I am having is how to maximize the flexibility of the system by making sure that each layer within the web service hierarchy (web service stub/business/data layer) is independent of one another. One of the decisions that I have to make is whether or not to return a domain model object type via a web service method. For instance, suppose that I have the following domain model object:

Case A:


public class Product

{

 public string name;

 public string sku;

 public double price;



 public Product() {}



 public Product(string name, string sku, double price)

 {

  this.name = name;

  this.sku = sku;

  this.price = price;

 }

}

My business layer has a method that retrieves an object of type Product:


public class ProductBusiness

{

 public Product retrieveProduct()

 {

  return new Product("JellyBelly (8 oz.)", "PK09834", 2.50);

 }

}

My web service calls the retrieveProduct method:


[WebMethod]

public Product getProduct()

{

 ProductBusiness bus = new ProductBusiness();

 Product prod = bus.retrieveProduct();

 return prod;

}

In this example, the WSDL is driven by the domain model (what I call schema last). There
are a few drawbacks to this approach:

The Product data type in the domain model is tightly coupled to the datatype in the public web service interface.

If a public field is added to the Product domain model object, this public field will
be exposed via the WSDL.

If another class in the business model would like to access a public field on the Product
domain class, but we do not want to expose this public field via the web service, we would have to declare the field as non-public and expose the field to the client class via a helper class (or a helper method on the domain model class).

One solution would be to add a mapper class that would translate between the classes exposed via the public web service (WSDL) and the classes used internally by the business layer. One way to do this is to define the WSDL independently of any application domain model classes.

Case B:
Suppose that I defined the WSDL for a product called WSProduct:


public class WSProduct

{

  public string name;

  public string sku;

  public double price;

  public DateTime dateRetrieved;

}

And change the web method to use this class:


[WebMethod]

public WSProduct getWSProduct()

{

 ProductBusiness bus = new ProductBusiness();

 WSProduct prod = bus.retrieveWSProduct();

 return prod;

}

Now the web service method returns a class of type WSProduct, and it obtains
the object from the ProductBusiness class via the retrieveWSProduct() method.
The retrieveWSProduct method on the ProductBusiness class looks like this:


public WSProduct retrieveWSProduct()

{

 Product prod = new Product("JellyBelly (8 oz.)", "PK09834", 2.50);

 WSProduct wsProd = new WSProduct();

 wsProd.name = prod.name;

 wsProd.sku = prod.sku;

 wsProd.price = prod.price;

 wsProd.dateRetrieved = DateTime.Now;

 return wsProd;

}

The method creates a Product and a WSProduct class, and then it translates(copies)
the values from the Product class to the WSProduct class. It also sets the dateRetrieved field on the WSProduct class.

In this case, any changes to the Product domain model class will not affect the contract
exposed by the web service, since this contract is represented by the WSProduct definition
in the WSDL. Any changes to the WSProduct in the WSDL will only affect the ProductBusiness
object (retrieveProduct will need modification). The Product object will remain unchanged since it is only used internally and it is not exposed by the web service.

Now for the question:

Which method is preferred? I would think that the case B is preferred over case A since there is less coupling
between the web service interface and the underlying implementation.

Microsoft Architecture Patterns

2004-05-18T16:25:00.000-07:00

A link to some architectural patterns can be found here

Data Compatibility in WebServices

2004-05-18T11:52:00.000-07:00

Simon Guest has a blog post about data type compatibility between WebServices in different execution environments (Java and .NET) here

Delegates

2004-05-17T15:10:00.000-07:00


  ThreadStart ts = new ThreadStart(DelegateFunction);

  Thread t = new Thread(ts);

  t.Start(); //start the thread

  

  for (int i = 0; i < 1000; i++)

   t.Sleep(5);

The ThreadStart class takes a reference to a method that cannot have any input parameters. The DelegateFunction is defined as:


  public void DelegateFunction()

  {

   // Do something...

  }

The DelegateFunction is executed when the Thread.Start function is run. In this case, the ThreadStart delegate wraps the method call, so that the method can be called via a type instance. Delegates are used for callback functions, events and as an implicit interface contract. A delegate can reference a function that takes parameters:


 public delegate string FunctionPointer(int foo, string bar);

 

 public FunctionPointer fpi; 

 fpi = new FunctionPointer(Function);

The Function declaration loooks like this:


 string Function(int foo, string bar)

 {

  string temp = "";



  for (int i = 0; i < foo; i++)

   temp += bar;

 

  return temp;

 }

The same delegate can point to another function with the same signature


 string AnotherFunction(int foo, string bar)

 {

  string temp = "AnotherFunction";



  for (int i = 0; i < foo; i++)

   temp += bar;



  return temp;

 }

The following is a sample console application that demonstrates delegates. In Main(), the source class and each sink class is created. The source class is the class that will call the function in the sink class via the delegate reference. Each sink class contains a method called Callback that will be called by the source class. To hook up the Callback method in the sink class to the delegate in the source class, a reference to the delegate is created and the name of the callback function in the sink class is passed as a parameter to the delegate reference constructor:


 using System;

 

 namespace Delegate

 {

  class Class1

  {

   [STAThread]

   static void Main(string[] args)

   {

    SourceClass sc = new SourceClass();

    SinkAClass sac = new SinkAClass();

    SinkBClass sbc = new SinkBClass();

 

    // Hook up the function and execute

    sc.fp = new SourceClass.FunctionPointer(sac.Callback);

    sc.DoSomething();

 

    // Hook up a new sink

    sc.fp = new SourceClass.FunctionPointer(sbc.Callback);

    sc.DoSomething();

   }

  }

 

  public class SourceClass

  {

   public delegate void FunctionPointer(int arg1, string arg2);

   public FunctionPointer fp;

 

   public void DoSomething()

   {

    // call the function pointed to by fp;

    fp(3, this.ToString());

   }

  }

 

  public class SinkAClass

  {

   public void Callback(int arg1, string arg2)

   {

    Console.WriteLine(

"{0} Callback method was called with arguments: {1}, {2}", 

this.ToString(), 

arg1.ToString(), 

arg2);

   }

  }

 

  public class SinkBClass

  {

   public void Callback(int arg1, string arg2)

   {

    Console.WriteLine(

"{0} Callback method was called with arguments: {1}, {2}", 

this.ToString(), 

arg1.ToString(), 

arg2);

   }

  }

 }

TypePad vs Blogger

2004-05-17T14:52:00.000-07:00

So I used to use UserLand Radio My Blog, but I wanted to switch to a different blog host, so I tried out TypePad from SixApart. So I signed up for the 30 day trial, and once registered, I had pretty high hopes for sticking with TypePad. That is until I started to actually use their online tool for managing your blog. First I created a weblog, then I added 3 posts to my weblog. Once the posts were added, I cliked the View Weblog button to view my public blog. Unfortunately my posts were not updated. So I went back and added another post, and tried to view my blog again, but no luck, the post was not added. So then I went and took a look at the help pages, thinking that maybe I was doing something wrong, but I couldn't find anything. So guess what company is NOT getting my money every month? Contrast my experience with Blogger, which has a much simpler registration/weblog creation system. And the good thing about Blogger is that it did what I told it to do: create a post and update my weblog to display that post. It really doesn't take that much to make a customer choose a competitors product over your product, if your product does not perform the way the customer expects it to, based on the published features of your product...

Update: It must just take a while for the new entries to post to the TypePad blog, I can see them now.