One component of an application I’m writing uses a lot of regular expressions. To be sure I was using the right regular expressions, I’ve created this simple tiny tool to help me learn and verify regular expressions against my input data. Nothing fancy, but it might help someone out there.

For example, it took me a little while trying to find the proper regular expression to match all comments in an Xml file.

Download exe or source.

It might seem like a sudden change for me to blog about C# and ASP.NET MVC but it’s what I work with at my work and I’m loving it.  Plus I haven’t had the inspiration to use django in months.  From now on, most posts will be about C#, ASP.NET MVC, HTML, CSS, and many other acronyms…

This may be already have been obvious to you but I had been working with a slow query for a number of days before I really realised what was going on.

Here’s the scenario: You want to show a list of two or more fields from different sql tables on a single page but for some reason the longer the list gets, the page just keeps taking longer and longer to load.

In this example the fields to be demonstrated will be the forename, surname and city of residence of people.  The db contains three tables: person, personname and address.

Simply put, you may do something like this in your controller:

public ActionResult ViewAll() {
    IQueryable<Person> persons = (from person in this.db.Persons
                                  select person);
    return View(persons);
}

and this in your view:

<table>
<% foreach(Person person in Model) { %>
<tr>
<td><%= person.PersonName.Forename %></td>
<td><%= person.PersonName.Surname %></td>
<td><%= person.Address.City %></td>
</tr>
<%}%>
</table>

If you code this up and use Vandermotten’s DebuggerWriter you’ll see that it goes to the db each time it needs to look up the entry for the personname table or the address table.  On a very long list, you can imagine that so many db calls (although quick to execute) can take up a huge chunk of time.

This is where we use a custom object to be filled with the specific fields we require.  This means as soon as the variable is enumerated, it’s populated with everything we need!

public class MyPerson {
    public MyPerson(string forename, string surname, string city) {
        this.Forename = forename;
        this.Surname = surname;
        this.City = city;
    }

    public string Forename {get; private set;}
    public string Surname {get; private set;}
    public string City {get; private set;}
}

public ActionResult ViewAll() {
    IQueryable<MyPerson> fasterPersons = (from person in this.db.Persons
                               select new MyPerson(person.PersonName.Forename, person.PersonName.Surname, person.Address.City));
    return View(fasterPersons);
}

This new Linq will execute just the once and enumerate the MyPerson object with just the right info for each and every person in the table.

The view will have to be changed just slightly to:

<table>
<% foreach(MyPerson myPerson in Model) { %>
<tr>
<td><%= myPerson.Forename %></td>
<td><%= myPerson.Surname %></td>
<td><%= myPerson.City %></td>
</tr>
<%}%>
</table>

And there you have it.  This finished code will just execute the once and so will speed up the page load incredibly!  In a development platform I was seeing page load times dropping from ~2secs to 12ms.

Hope this helps anyone out there who just managed to find themselves here

 htmlscript="true"

In the past few years a lot of research has been done on page load times and where the hot spots occur. Surprisingly around 90% of the page load time is spent inside the browser. Why could this be happenning and what can be done in order to reduce these numbers?

How browsers work?

When a page is requested it is downloaded, parsed and rendered. During the rendering phase a lot is going on behind the scenes – static resources referenced by the page are downloaded, parsed and executed (in case of CSS and JavaScript). These static resources require additional HTTP requests which might dramatically slow down the loading of the page. Browsers have a limit of requests that could be performed in parallel, hence the resources are downloaded somewhat sequentially. The numbers differ from browser to browser, but in general two image files could be downloaded in parallel from a single domain, only a single JavaScript file could be downloaded at a time which also blocks the rendering of the page.

JavaScript hot spots

In this article the subject of interest are the bottlenecks that arise from requesting JavaScript files. There are different steps that could be taken to tune the page load time that is influenced by script files – minification and compression, combining all scripts in a single file (this is the recommended approach for CSS as well). There are several tools that are available for this purpose – JSMin and YUI Compressor (there is a .NET version that could be used in a MSBuild task) are some of them. You could make significant performance gains by minimizing and compressing – that could really be felt if your users are on a slow internet connection. By combining your scripts the browser will make only a single HTTP request which results in faster load times.

I will show you how to use YUI Compressor for .NET to combine and minify JavaScript files with MSBuild. To get started you need to copy Yahoo.Yui.Compressor.dll and EcmaScript.NET.modified.dll assemblies to your project. Create a so called project file (XML file that is constructed according to the MSBuild XML Schema definition) that is used to instruct the build engine what to do. I will not get into the details because MSBuild is not the subject of this post. Here is the project file:

<?xml version="1.0" encoding="utf-8" ?>
<Project xmlns="http://schemas.microsoft.com/developer/MsBuild/2003">
  <UsingTask
      TaskName="CompressorTask"
      AssemblyFile="Yahoo.Yui.Compressor.dll" />

  <Target Name="MyTaskTarget">
    <ItemGroup>
      <JavaScriptFiles Include="..\Scripts\jquery-1.3.2.js"/>
      <JavaScriptFiles Include="..\Scripts\MicrosoftAjax.js"/>
      <JavaScriptFiles Include="..\Scripts\MicrosoftMvcAjax.js"/>
    </ItemGroup>
    <CompressorTask
        CssFiles="@(CssFiles)"
        DeleteCssFiles="false"
        CssOutputFile="$(CssOutputFile)"
        CssCompressionType="YuiStockCompression"
        JavaScriptFiles="@(JavaScriptFiles)"
        ObfuscateJavaScript="True"
        PreserveAllSemicolons="False"
        DisableOptimizations="Nope"
        EncodingType="Default"
        DeleteJavaScriptFiles="false"
        LineBreakPosition="-1"
        JavaScriptOutputFile="$(JavaScriptOutputFile)"
        LoggingType="ALittleBit"
        ThreadCulture="en-us"
        IsEvalIgnored="false"
            />
  </Target>
</Project>

The important part is the ItemGroup element in which you specify the scripts that will be acted upon by YUI Compressor. Next you should edit the Build event script in order to run the MSBuild task. Right-click the project and choose Properties, then select Build Events. In the Post-build event command line enter the following script:

$(MSBuildBinPath)\msbuild.exe "$(ProjectDir)MSBuild\MSBuildXML.xml" /p:JavaScriptOutputFile="$(TargetDir)..\Scripts\JavaScriptFinal.js"

Project Properties - Build Events

Now when you build your project your JavaScript files would be combined and minified – the output can be seen in this screenshot:

MSBuild output

Another important aspect is where exactly in the page are the references for the JavaScript files. You should put them in the head section of the HTML document only if the scripts are essential for the page rendering phase (generation of HTML), otherwise you should put them at the end of the page to prevent blocking of the rendering. If you know that your script won’t be needed until a specific time on your page you could defer its loading. This way the browser won’t make a request for it and you will improve the page load time. It is really easy to accomplish – all you need to do is to attach an event handler to the onload event and download the file after a specified amount of time. Here is a sample HTML extension method for ASP.NET MVC that I wrote but this could be easily rewritten for ASP.NET:

private static string RegisterDeferredLoader(this HtmlHelper helper)
{
    HttpContextBase context = helper.ViewContext.HttpContext;
    if (context.Items.Contains("__DeferredLoader"))
        return "";

    context.Items.Add("__DeferredLoader", "__DeferredLoader");

    StringBuilder strBuilder = new StringBuilder();
    strBuilder.AppendLine("<script type=\"text/javascript\">");
    strBuilder.AppendLine("function loadScript(file){");
    strBuilder.AppendLine("var script = document.createElement('script');");
    strBuilder.AppendLine("script.type = \"text/javascript\";");
    strBuilder.AppendLine("script.src = file;");
    strBuilder.AppendLine("document.body.appendChild(script);");
    strBuilder.AppendLine("};");
    strBuilder.AppendLine("</script>");

    return strBuilder.ToString();
}

This private helper method outputs a JavaScript function on the page that initiates the request for the script file itself – it simply creates a SCRIPT DOM element and sets its src attribute to the URI of the file. When it is appended to the document the script file is downloaded automatically. The method also ensures that the JavaScript function is written only once in the HTML document – we do not want it multiple times which increases the overall size of the document that would be transferred.

Here is the extension method that would be used to defer the loading of scripts on the page:

public static string RegisterScript(this HtmlHelper helper, string resourceUri, int delayInMilliseconds)
{
    HttpContextBase context = helper.ViewContext.HttpContext;
    if (context.Items.Contains(resourceUri))
        return "";

    context.Items.Add(resourceUri, resourceUri);
    StringBuilder strBuilder = new StringBuilder();
    strBuilder.AppendLine(helper.RegisterDeferredLoader());

    strBuilder.AppendLine("<script type=\"text/javascript\">");
    strBuilder.AppendFormat("if (window.addEventListener) window.addEventListener('load', function(){{window.setTimeout(function(){{loadScript(\"{0}\");}}, {1});}}, false);", resourceUri, delayInMilliseconds);
    strBuilder.AppendFormat("else if (window.attachEvent) window.attachEvent('onload', function(){{window.setTimeout(function(){{loadScript(\"{0}\");}}, {1});}});", resourceUri, delayInMilliseconds);
    strBuilder.AppendLine("</script>");

    return strBuilder.ToString();
}

This method outputs JavaScript code that attaches an event handler to the onload event of the window in which the loadScript function is called after a specified number of milliseconds. As you can see all of this is accomplished with a minimum amount of code and there is no complex logic. In order to use the extension method in your pages you should add its namespace to the pages/namespaces element inside the web.config file:

<pages>
    ...
    <namespaces>
        ...
        <add namespace="JSOptimizations.Helpers"/>
    </namespaces>
</pages>

What follows is a simple test of the extension method. This is a very simple JavaScript file that renders the time at which it is executed:

document.body.innerHTML += 'I am now loaded at ' + new Date();

And the HTML for the page is as follows:

<%@ Page Language="C#" Inherits="System.Web.Mvc.ViewPage" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title>DeferLoading</title>
    <%= Html.RegisterScript("../../Scripts/DeferLoading.js", 5000) %>
</head>
<body>
    <script type="text/javascript">
        document.body.innerHTML += 'Page is rendered at: ' + new Date() + '<br/>';
    </script>
</body>
</html>

When you open it you would see something similar to the screenshot:

Deferred Loading of JavaScript

As you can see the JavaScript file is loaded exactly 5 seconds after the page is rendered.

You could download the sample test project with both the MSBuild task and the extension methods from here.

Summary

Simply by utilizing some techniques for loading JavaScript files you could dramatically increase the load times of your pages. Both minifying and combining several files into a single one can save significant amount of bandwidth. Deferred loading allows you to download scripts after the page has loaded thus reducing the network round trips to the server while rendering the page. There is no single golden rule that will help you achieve the best performance but when you use different techniques for your specific scenario you could really make great improvements.

Action filters are a powerful mechanism in ASP.NET MVC to add an additional layer of control to your action methods by attaching to the request-response pipeline. Just by decorating an action method or controller class you can perform a custom authorization based on specific rights and roles, cache and/or compress the response, localization, etc.

Implementation

In order to implement a custom action filter you need to inherit from ActionFilterAttribute – this is an abstract class that has four methods that you can override:

• OnActionExecuting
• OnActionExecuted
• OnResultExecuting
• OnResultExecuted

As their names imply a custom logic can be performed before/after an action method is executed and before/after the result is executed. Action filters have an Order property which specifies the order in which the filter is applied when multiple filters are used to decorate an action method.

Performance Optimizations

Nowadays with broadband internet a lot of people do not care about the performance of their web sites but they are wrong. Every single byte counts when you want to stand out – the end users do not care about what technology is powering up your system, they do care about performance. One of the first things that you could do to reduce the payload of your site is to do gzip or deflate compression – it will reduce the size of the server response by 60-65%. Compression is only applicable if the end user’s browser supports it – all major browsers support it so you do not need to worry. Gzip is more widely accepted and performs better than deflate, hence it should be your first choice.

Note: Do not apply compression to images and PDF files – they are already compressed and you will only waste CPU time to do so.

Compression Filter

Here is the code for the compression filter:

public class CompressionAttribute : ActionFilterAttribute
{
    public override void OnActionExecuting(ActionExecutingContext filterContext)
    {
        base.OnActionExecuting(filterContext);

        HttpRequestBase request = filterContext.HttpContext.Request;
        string acceptEncoding = request.Headers["Accept-Encoding"].ToLowerInvariant();
        if (string.IsNullOrEmpty(acceptEncoding))
            return;

        HttpResponseBase response = filterContext.HttpContext.Response;
        if (acceptEncoding.Contains("gzip"))
        {
            response.AppendHeader("Content-Encoding", "gzip");
            response.Filter = new GZipStream(response.Filter, CompressionMode.Compress);
        }
        else if (acceptEncoding.Contains("deflate"))
        {
            response.AppendHeader("Content-Encoding", "deflate");
            response.Filter = new DeflateStream(response.Filter, CompressionMode.Compress);
        }
    }
}

The Accept-Encoding header of the request shows whether the browser supports compression – if it is empty the CompressionAttribute class returns and does nothing. If the value is gzip or deflate the HttpResponseBase class’s property Filter which is of type Stream is wrapped by GZipStream or DeflateStream respectively. A Content-Encoding response header is set to the value of the compression method that is used so that the browser will know how to decompress the response.

Here is a sample usage of the Compression filter:

[Compression]
public ActionResult Index()
{
    return View();
}

Summary

Custom action filters give some extra power in the hands of developers to perform additional tasks along the ASP.NET MVC pipeline. You saw how simple it is to write a custom action filter that is applicable to real world scenarios. This is one of the performance optimization techniques that you could apply to improve the overall performance of your site.

This is part zero of a multi-part series. Jump to The Poor Developer’s Object DataStore: Iteration 001 for the first code drop.

What is an object datastore? For an object-oriented developer it’s as easy to use as a typed collection. No need to build and maintain a complex relational model to simulate the native object functionality. Just create your object, modify it, store it, query for it and delete it. All the complicated work is handled by the object database engine. But let’s consider a situation where you may want to “roll your own” light-weight object datastore. And depending on your situation, it might make sense. CAVEAT: Rule #1 of Software Engineering: If You Can Use A Proven Product Don’t Write Your Own. They Did It First And They Did It Better. But for the sake of exercise and trying something new let’s just ignore that rule and keep on going.

Consider the following scenario. You’re a .NET developer and you’ve been tasked with creating an archiving system. The system needs to take a snapshot of the data and store it to be queried against and reported on later.

How would you implement this? Would you copy the data structure you’re looking to archive and pull the data state into there? How do you manage foreign keys? Do you squish the data into a single table? Do you recreate all the tables with annotations to identify the archived records? Now, it’s a few months later and the original data structure has changed. How do you handle that change in your archiving?

Do you really want to recreate that complex data structure and try to wrangle the data into it and manage it over time? No, neither did I and I think there is a better way. Let’s consider a new way: an object datastore.

Let’s get this out of the way. Object databases aren’t just for ninjas although they are often wielded by ninjas. An object database is exactly what it sounds like, a database for your objects. No sql, no tables, no object-relational impedance. Just objects persisted similar to how a relational database allows you to store and persist tabular information offline without all the grief of mapping your object-oriented structure onto a relational model. Instead you create your objects and using the database’s API you can save and query for your data without worrying about sql or any of that mess. My personal favorite OODBMS (object-oriented database management system) is db4o. I recommend downloading and playing around with it to get a feel for how simple it is to use. (If you want to learn more about various types of *DBMS check out the great presentation by Ben Scoffield at WindyCityRails 2009 – “Comics” is Hard.)

There’s one catch to using db4o in a closed source or proprietary project. You can either pay to license the product. It’s not too expensive for bringing into a medium sized project. Or you can release your project under GPL. For the project I was working on, neither option was palatable for our client. Also, I didn’t want to introduce yet another external dependency that our client would have to manage. Instead I created the simplest possible implementation of an object datastore I could using only native .NET and Microsoft Sql Server functionality.

Continued in The Poor Developer’s Object DataStore: Iteration 001.

Biar ngodingnya rapih, bersih dan gaya (apaan sih ), alangkah baiknya baca Coding Style Guidenya dulu.

C# Coding Style Guide v0.4 by Mike Krüger

This document may be read as a guide to writing robust and reliable programs. It focuses on programs written in C♯, but many  of the rules and principles are useful even if you write in another programming language.

Link downloadnya di sini:

http://www.mediafire.com/?bcymh2mo1n2

ASP.NET MVC is the new cool kid on the block of Microsoft platforms. I have been using it for a little over half an year and I can say that I like it much more than ASP.NET. Why is that?

1. No more viewstate which adds an additional overhead on your page
2. Clean separation of concerns through the MVC pattern
3. Going back to the basics (standard HTML controls) – most of the ASP.NET server controls do not work with ASP.NET MVC because there is no viewstate and the notion of postbacks

This would be the first of a series of blog posts that I would write about ASP.NET MVC and some performance techniques that could get the most out of it. We will start by building a simple application that uses Ext JS Grid to display employees data that is fetched from the AdventureWorks database. Since jQuery is being shipped with Visual Studio for over a year now I will be using it as well – as an adapter to Ext JS (I am a big fan of jQuery).

I am going to create my app using Visual Stidio 2010 Beta 2 which ships with ASP.NET MVC 2 Beta. If you are using Visual Studio 2008 you have to download the Beta and install it on your machine. First we start by creating a new ASP.NET MVC Project.

New ASP.NET MVC Project

Next I am copying the necessary files that are needed for Ext JS – ext-all.debug.js and ext-jquery-adapter.js to an extjs folder I created under my Scripts folder which was created for me by the ASP.NET MVC project template. I will use the latest version of the library – Ext JS 3.0.3.

In the next step we need to include the css and js files – I will put them in the master page (located under Views/Shared folder):

<link href="../../Content/resources/css/ext-all.css" rel="stylesheet" type="text/css" />
<script type="text/javascript" src="../../Scripts/jquery-1.3.2.js"></script>
<script type="text/javascript" src="../../Scripts/extjs/ext-jquery-adapter.js"></script>
<script type="text/javascript" src="../../Scripts/extjs/ext-all-debug.js"></script>

The order in which you include the JavaScript files is important.

Note: Please remember that it is essential to put all your css files in the head section of the page – this improves the loading of your page. All js files that are needed for the page rendering should also be put in the head, otherwise they should be put at the end of your page. I will talk more about this in a future blog post.

For the purpose of this sample application I will use the AdventureWorks database alongside with the Entity Framework for my data model. First we have to add the database into the App_Data folder and then create our data model in the Models folder. The Entity Framework will generate all the necessary entities and a context class and we are ready to write our data access code – I will write my LINQ queries against the database in the controller classes though you will not do this in a real world application. You would use for example the Repository pattern, put your data access logic in a separate assembly, maybe write your own services that will abstract away the business logic and inject them with some Dependency Injection framework, etc.

Entity Framework Data Model

Now that we have everything in place we can write an action method which would return a subset of employees:

[AcceptVerbs(HttpVerbs.Get)]
[ActionName("Employees")]
public JsonResult GetEmployees()
{
   int start = Convert.ToInt32(Request.QueryString["start"]);
   int limit = Convert.ToInt32(Request.QueryString["limit"]);

   using (AdventureWorksEntities dbContext = new AdventureWorksEntities())
   {
      var query = dbContext.Employees
                              .Include("Contact")
                              .OrderBy(emp => emp.EmployeeID);
      var result = (from emp in query
                                  .Skip(start).Take(limit).ToList()
                    select new
                    {
                       ID = emp.EmployeeID,
                       FirstName = emp.Contact.FirstName,
                       LastName = emp.Contact.LastName,
                       BirthDate = emp.BirthDate.ToShortDateString(),
                       HireDate = emp.HireDate.ToShortDateString(),
                       VacationHours = emp.VacationHours,
                       SickLeaveHours = emp.SickLeaveHours,
                       Email = emp.Contact.EmailAddress,
                       Phone = emp.Contact.Phone
                    }).ToList();

      return Json(new { data = result, totalCount = query.Count() }, JsonRequestBehavior.AllowGet);
   }
}

Notice the AcceptVerbs attribute that the method is decorated with – it tells the framework that only GET requests are allowed to call the method through the HttpVerbs enumeration. This was the way to constrain the requests so far but in the new version of ASP.NET MVC there are some new handy attributes that you could use as well – HttpGet, HttpPost, HttpPut and HttpDelete which do the same thing. I am using the ActionName attribute to explicitly add a name for my action method so that I could have a nice URL schema for my actions and use the same name for different CRUD operations (I just need to use different verb for the requests).

In the method itself I create an instance of the database context and based on the parameters received from the grid I do paging with the LINQ extension methods Skip and Take. The interesting part is when the data is returned as a JSON – in ASP.NET MVC 1 the JSON method required a single parameter while now you have to pass an additional parameter of type JsonRequestBehavior. It is introduced for security reasons and you as a developer should explicitly decide whether or not to support GET requests. The problem is that if you return a response in the form of a JSON Array for a GET request it could be easily compromised, so it is suggested to wrap it inside a JSON object or do POSTs instead of that. You could read more about this in Phil Haack’s post.

Next we need to write the JavaScript code that will instantiate our grid and fetch the data from the server:

<script type="text/javascript">
   $(document).ready(function () {
      var store = new Ext.data.Store({
         proxy: new Ext.data.HttpProxy({
            url: 'Home/Employees',
            dataType: 'json',
            method: 'GET'
         }),
         reader: new Ext.data.JsonReader({
            root: 'data',
            totalProperty: 'totalCount'
         }, Ext.data.Record.create([
            { name: 'ID', mapping: 'ID' },
            { name: 'FirstName', mapping: 'FirstName' },
            { name: 'LastName', mapping: 'LastName' },
            { name: 'BirthDate', mapping: 'BirthDate' },
            { name: 'HireDate', mapping: 'HireDate' },
            { name: 'VacationHours', mapping: 'VacationHours' },
            { name: 'SickLeaveHours', mapping: 'SickLeaveHours' },
            { name: 'Email', mapping: 'Email' },
            { name: 'Phone', mapping: 'Phone' }
         ]))
      });

      var grid = new Ext.grid.GridPanel({
         store: store,
         columns: [
            { header: 'ID', dataIndex: 'ID', hidden: true },
            { header: 'First Name', dataIndex: 'FirstName', width: 100 },
            { header: 'Last Name', dataIndex: 'LastName', width: 100 },
            { header: 'Birth Date', dataIndex: 'BirthDate', width: 100 },
            { header: 'Hire Date', dataIndex: 'HireDate', width: 100 },
            { header: 'Vacation Hours', dataIndex: 'VacationHours', width: 100 },
            { header: 'Sick Leave Hours', dataIndex: 'SickLeaveHours', width: 100 },
            { header: 'Email', dataIndex: 'Email', width: 200 },
            { header: 'Phone', dataIndex: 'Phone', width: 200 }
         ],
         renderTo: 'grid',
         width: 1000,
         autoHeight: true,
         bbar: new Ext.PagingToolbar({
            store: store,
            pageSize: 25,
            displayInfo: true,
            displayMsg: 'Displaying employees {0} - {1} of {2}',
            emptyMsg: "No employees to display"
         }),
         pageSize: 20,
         title: 'Employees'
      });

      grid.getStore().load({ params: {
         start: 0,
         limit: 25
      }
   });
});
</script>

When the DOM is ready to be manipulated I create a Store which will make the request to the server and use a JsonReader object which has all the necessary mappings in place to parse the data. Then an instance of the Grid is created with the store that was created in the previous step and columns which are mapped to the parsed JSON result object. That’s all you need to do – create these objects passing some configurations and you are ready to get your data. All the tricky parts of making an XmlHttpRequest, parsing the JSON, creating the HTML for the grid is done for you. Here is how the grid looks like when the application is run:

Ext Js Grid

This is a simple application in which I wanted to show you how to use Ext JS Grid to present data in a nice tabular fashion using ASP.NET MVC and Entity Framework. Here you could download the code for this app (I have not included the AdventureWorks database in order to keep the file size small, but you could download it from here).

In my next blog post I will show you how to write ASP.NET MVC HTML extension methods to include CSS and JavaScript files in your pages and how to instantiate some jQuery UI plugin widgets.

In The Poor Developer’s Object DataStore : Iteration 000 we proposed a possible motivation for wanting to store complex objects in a database without resorting to creating a complicated relational model.

For our first iteration we need only to be able to create and read the object from the database. It’s not going to be necessary to update or delete the data at this point. Only store and read. So why bother recreating the original data structure? Why not just query for the data with your ORM of choice and then serialize that result to Xml and store that? If you’re already using Microsoft Sql Server 2005 or later you’re already in a very good position as MSSQL provides the Xml datatype which makes storing, querying and retrieving Xml data very
easy and efficient.

If you are using an ORM for your data-access (you *ARE* using an ORM aren’t you?) then you’re already halfway there. My original implementation utilized custom objects that implemented an IStorable interface. Basically, I used Linq to Sql to query the data I wanted to archive and mapped the query result to an object that implemented the interface. Using that I could save the object into the datastore in a similar manner to Active Record. This was very easy to do.

public interface IStorable<T>
{
  string ConnectionString { get; set; }
  string Serialize();
  T Deserialize(string xml);
  XmlSerializer CreateSerializer();
  int Save();
}

So I could load up my data into a custom object, set the connectionstring and then automatically save it into the database.

//a sample unit test demonstrating usage of the IStorable object.
public void TestStoreFoo()
{
  var foo = new Foo();
  foo.Id = 100;
  foo.Name = "Penelope";
  foo.ConnectionString = "__YourConnectionString__"
  var objectId = foo.Save();
  Assert.That(objectId == 1);
}

So here’s the implementation. If you wish to grab the source code don’t try to cut and paste it from here. All the source code for this blog post can be browsed and downloaded from GitHub.

Source Code for Iteration 001

First we must implement the IStorable interface. The interface must take the implementing type as it’s generic argument. This is because we’re providing functionality for the object to serialize and store itself.

public class Foo : IStorable<Foo>
{

The Foo.Id and Foo.Name are our data. They are not part of the IStorable implementation.

  public int Id { get; set; }
  public string Name { get; set; }

We need to provide the connectionstring to the database where the objects are going to be stored.

  public string ConnectionString { get; set; }

Now we’re getting to the fun part. We will use an in-memory stream to serialize this instance of the Foo object and then write it to a string.

  public string Serialize()
  {
    string output;
    using(var buffer = new MemoryStream())
    {
      new XmlSerializer(typeof(Foo)).Serialize(buffer, this);
      buffer.Position = 0;
      output = new StreamReader(buffer).ReadToEnd();
    }
    return output;
  }

The deserialize method takes the xml as a string from a previous serialization and will attempt to convert it back into a Foo instance.

  public Foo Deserialize(string xml)
  {
    return (Foo)new XmlSerializer(typeof(Foo)).Deserialize(new StringReader(xml));
  }

In order to serialize a type we must create a typed instance of a serializer object. Here we’re just creating a Foo serializer and setting the error event handlers to output it’s errors to standard output.

  public XmlSerializer CreateSerializer()
  {
    var serializer = new XmlSerializer(typeof(Foo));
    //simply output error messages for types that we don't know how to serialize.
    serializer.UnknownAttribute += ((sender, e)=>Console.Out.WriteLine(e));
    serializer.UnknownElement += ((sender, e)=>Console.Out.WriteLine(e));
    return serializer;
  }

The save method is where we will kick off the work. We take this current instance and apply the Serialize() method to itself which converts the instance to a xml string. We also capture the fully-qualified name of the object type, both the namespace and the type name. This will be important when we are ready to pull the object back out of the datastore.

Here I’m using a Linq to Sql context, you may use any ORM as long as it supports the Microsoft Sql Server Xml datatype.

  public int Save()
  {
    using(var context = new Example001DataContext(this.ConnectionString))
    {
      var entity = new Example001ObjectDataStore {
        Serialized = XElement.Parse(this.Serialize()),
        FullyQualifiedTypeName = this.GetType().FullName
      };
      context.Example001ObjectDataStores.InsertOnSubmit(entity);
      context.SubmitChanges();
      return entity.Id;
    }
  }
}

The underlying data table is very simple. Only a single table with a field for storing the serialized xml data and a field for storing the fully qualified name of the object.

The Iteration 001 Object DataStore Table Definition

In this post we’ve got the ball rolling for storing objects into some some table. We can create an object that knows how to write itself into a database without requiring the creation of an elaborate data structure in order to just to simulate the object structure.

Next post we’ll cover how to retrieve the data from the table and convert it back into an instance of the persisted type. Next post we’ll look at how we can really test the functionality and behavior of the system. And begin to explore how to abstract the datastore to support arbitrary objects (with some minor restrictions.)

The source code for this project is hosted on GitHub and can be downloaded from here.

SCRIBEFIREol26UBNsSCRIBEFIRE

In Computer Networking, Ports are virtual data connection between clients and servers. Ports are assigned port numbers which makes us easier to understand what kind of service is running on it.

A Port Scanner is a program which checks for open ports in a specified network host. For example: A printer with the IP Address of 10.44.55.17 may run a HTTP port in port number 80 to display the print configuration page. You can scan for open ports in a host to see what services are running in it. For example: A FTP client can be listening to Port 21. A port number can be a value from 0 to 65536, but the port numbers 0 to 1024 are reserved to be used by certain privileged services.

List of “well-known ports”.

Additionally, In Windows XP,Vista and 7 you can type netstat in the command prompt to check for list of Active Connections with IP Address and Port Number.

Writing a simple port scanner  in C#

Download Source Code

First, add reference to System.Net.Sockets in you program and include a using statement(using System.Net.Sockets;) in your list of using directives.

The program will have a button, which when pressed should start scanning for ports. Also four text boxes but one must have the multiline property enabled. One text box will have the IP Address of the host, two other text boxes will have the port start port and end point. The text box having multiline property enabled should be of suitable height so that it can accommodate 10-12  items without scrolling it. Lastly, You can add a progress bar to check the scan progress.

Code

When the user clicks the ‘Scan’ button the button_Click event handler should execute the following lines of code.

//START CODE BLOCK

progressBar1.Value = 0;
txtPortStats.Text = “”;
int portLowerLimit = Convert.ToInt32(txtFromIP.Text);
int portUpperLimit = Convert.ToInt32(txtToIP.Text);
progressBar1.Maximum = portUpperLimit-portLowerLimit + 1;
string ip = txtIPAddress.Text;

for (int i = portLowerLimit; i <= portUpperLimit; i++)
{
TcpClient client = new TcpClient();
try
{
client.Connect(ip, i);
txtPortStats.Text += i.ToString() + ” is Open”;
txtPortStats.Text += Environment.NewLine;
progressBar1.Value++;

}
catch
{
txtPortStats.Text += i.ToString() + ” is Closed”;
txtPortStats.Text += Environment.NewLine;
progressBar1.Value++;
}
}

//END CODE BLOCK

From Here:

• Enable the application to use the multi-threading capability of your CPU… multi-threading prevents the application UI from freezing and the scanning process can be completed faster.
• Make the progress bar more accurate.

Send mail trong ASP.NET sử dụng C# Class dùng để gửi mail tới 1 hay nhiều người, có cho phép đính kèm tệp tin vào email…

Việc gửi mail là 1 công việc thường ngày và viết ra 1 chương trình gửi mail thật đơn giản nhưng không phải ai cũng biết. Mình xin giới thiệu với các bạn class Email này.

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Net.Mail;

namespace EmailClass
{
public class Email
{
public string Send_Email(string SendFrom,string SendTo, string Subject, string Body)
{
try
{
System.Text.RegularExpressions.Regex regex = new System.Text.RegularExpressions.Regex(@”\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*”);

bool result = regex.IsMatch(to);
if (result == false)
{
return “Địa chỉ email không hợp lệ.”;
}
else
{
System.Net.Mail.SmtpClient smtp = new SmtpClient();
System.Net.Mail.MailMessage msg = new MailMessage(SendFrom,SendTo,Subject,Body);
msg.IsBodyHtml = true;
smtp.Host = “smtp.gmail.com”;//Sử dụng SMTP của gmail
smtp.Send(msg);
return “Email đã được gửi đến: ” + SendTo + “.”;
}
}
catch
{
return “”;
}
}

public string Send_Email_With_Attachment(string SendTo, string SendFrom, string Subject, string Body, string AttachmentPath)
{
try
{
System.Text.RegularExpressions.Regex regex = new System.Text.RegularExpressions.Regex(@”\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*”);

string from = SendFrom;
string to = SendTo;
string subject = Subject;
string body = Body;

bool result = regex.IsMatch(to);

if (result == false)
{
return “Địa chỉ email không hợp lệ.”;
}
else
{
try
{
MailMessage em = new MailMessage(from, to,subject, body);
Attachment attach = new Attachment(AttachmentPath);

em.Attachments.Add(attach);
em.Bcc.Add(from);
System.Net.Mail.SmtpClient smtp = new SmtpClient();
smtp.Host = “smtp.gmail.com”;//Ví dụ xử dụng SMTP của gmail
smtp.Send(em);
return “”;
}
catch (Exception ex)
{
return ex.Message;
}
}
}

catch (Exception ex)
{
return ex.Message;
}
}

public string Send_Email_With_BCC_Attachment(string SendTo, string SendBCC, string SendFrom, string Subject, string Body, string AttachmentPath)
{
try
{
System.Text.RegularExpressions.Regex regex = new System.Text.RegularExpressions.Regex(@”\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*”);
string from = SendFrom;
string to = SendTo; //Danh sách email được ngăn cách nhau bởi dấu “;”
string subject = Subject;
string body = Body;
string bcc = SendBCC;

bool result = true;
String[] ALL_EMAILS = to.Split(‘;’);

foreach (string emailaddress in ALL_EMAILS)
{
result = regex.IsMatch(emailaddress);
if (result == false)
{
return “Địa chỉ email không hợp lệ.”;
}
}

if (result == true)
{
try
{
MailMessage em = new MailMessage(from, to, subject, body);
Attachment attach = new  Attachment(AttachmentPath);
em.Attachments.Add(attach);
em.Bcc.Add(bcc);

System.Net.Mail.SmtpClient smtp = new SmtpClient();
smtp.Host = “smtp.gmail.com”;//Ví dụ xử dụng SMTP của gmail
smtp.Send(em);

return “”;
}
catch (Exception ex)
{
return ex.Message;
}
}
else
{
return “”;
}
}
catch (Exception ex)
{
return ex.Message;
}
}
}
}

Hello everybody,

a few days ago a friend asked me how to get the temporary folder of the current system.
So I decided to write a short post on my Blog.

Well if you want to get the temporary folder you can use the following code as an example

string tmp = Path.GetTempPath();

string tmp2 = Environment.GetEnvironmentVariable("TEMP");
//The two methods should return the same result

Regards
Michael

I know what you’re thinking, and the answer is YES. It does remember all of the settings each time you open it! You’ll be able to save and load configurations shortly, too.

List2Code is very Simple Application that takes comma delimited list and runs it a template to create code that can be copied and pasted in your application. The Goal is to quickly create large amount of properties or xml files using a comma delimited list.

List2Code Main Window

The Code and Source Code is available on CodePlex http://list2code.codeplex.com/

Here is some Template’s You can use.

Template Example’s

Clone a Object Template

{0}=fromobj.{0};


*where the fromobj the object is that you want to clone from.

Normal Property Template

public {0} {1} {get;set;}


INotifyPropertyChanged Property Template


private {0} m_{1};
public {0} {1}
{
get { return m_{1}; }
set
{
if (value != m_{1})
{
m_{1} = value;
if (PropertyChanged != null)
PropertyChanged(this, new PropertyChangedEventArgs("{1}"));
}
}
}


SELECT COLUMN_NAME
FROM INFORMATION_SCHEMA.COLUMNS
WHERE TABLE_NAME = 'TableNameGoesHere'
ORDER BY ORDINAL_POSITION

Para quem está começando a desenvolver em uma linguagem, uma as principais dúvidas é sobre o tipo de variável que a linguagem suporta. No C# os tipos de variáveis podem ser:

e abaixo tem a faixa de valores que cada tipo suporta

C# – Simples, Objetivo e sem mistério.

So many times I asked people to take a look at csharp tutorial, but nobody listens. Why ?

Well, opened up a new blog. Banner looks professional.
Anyone who needs proxy lists, we frequently update them. Atleast 3 a day of around 100 proxies.
As i speak i am scanning a proxy list of 200.

Anyways, head on over to it!
click here to head on over to the superb proxy blog

Well, opened up a new blog. Banner looks professional.
Anyone who needs proxy lists, we frequently update them. Atleast 3 a day of around 100 proxies.
As i speak i am scanning a proxy list of 200.

Anyways, head on over to it!
click here to head on over to the superb proxy blog

Un par de artículos que explican como extender la funcionalidad de los Enumerados en c#. via.

Hoạt động của Webpart

Với đa số mọi người, đây gần như là cách tiếp cận duy nhất. Có nhiều bài hướng dẫn tạo ra Webpart. Các Webpart có nhiều điểm nổi trội so với những giải pháp cho vấn đề trong Sharepoint. Và trong vài trường hợp, chúng là giải pháp tốt nhất cho công việc.

Một ưu điểm lớn nhất của Webpart là mọi thứ đều có snawx. Bạn có thể thao tác với thanh công cụ, thay đổi mọi thứ theo cách của Webpart. Với control, bạn chỉ có thể thực hiện với những gì có sẵn mà thôi.

Mặt khác, điểm mạnh của User Control là điểm yếu của Sharepoint. Nó là một khái niệm mới, lạ lẫm, có thể mất thời gian để làm quen và tăng thời gian phát triển. Webpart lại có ưu điểm về hoạt động. Webpart là giải pháp có hiệu suất tối đa nhất, được hỗ trợ bởi kiến trúc khung trong cơ chế triển khai cơ sở hạ tầng Sharepoint. Tuy nhiên, như đã nói, điều này chỉ có ý nghĩa trong các tổ chức lớn, với các ứng dụng lớn đòi hỏi mở rộng. Trong thực tế, sự khác nhau là không lớn.

Đánh giá

Vì sự hiểu biết cơ bản về sự khác nhau là không đủ. Mục này sẽ đề cập sâu hơn về điểm mạnh và yếu trong các trường hợp khác nhau.

Lập trình trực quan

Một khi yếu tố quen thuộc không còn là lợi thế để cho việc lập trình nhanh chóng hơn thì tôi sẽ nghiêng về chọn Webpart. Lập trình dao diện kéo thả được hỗ trợ rất mạnh bởi Visual Studio. Cái này sẽ khiến nhiều người suy nghĩ làm thế nào tận dụng hỗ trợ kéo thả đó.Tuy nhiên, theo tôi, muốn có một giao diện linh hoạt mềm dẻo. Thì chúng ta sẽ phải dùng những cách trang trí riêng, phù hợp với những hoàn cảnh khác nhau. Hoặc khi muốn hiển thị một tập các links hoặc thay thế một chuỗi trong ouput, những lợi thế của User Control trở nên vô dụng. Trong trường hợp này, rõ ràng Webpart là sự lựa chọn hợp lý.

Đồng bộ

Một trong những ưu điểm của User Control là bạn có thể mang nó từ một trang Sharepoint vào trong một ứng dụng ASP.NET khác. Tuy nhiên, điều gì xảy ra nếu trong User Control đó lại sử dụng thư viện Microsoft.Sharepoint.dll. Tất nhiên là không thể dùng nó ngoài Sharepoint được nữa rồi. Vì thế lợi thế sử dụng lại biến mất khi bạn sử dụng trực tiếp các tính năng trong Sharepoint. Trong trường hợp này, nếu giao diện là được giản thì hợp lý hơn là code bằng Webpart. Webpart có sự đồng bộ cần và tích hợp sâu vào Sharepoint.

Hoạt động

Mặc dù hiệu suất hoạt động của một ứng dụng luôn nằm trong đầu của người lập trình. Tuy nhiên, ngày nay, một cái Server có giá khoảng $5000, trong nhiều dự án, nó chỉ có giá trị rất nhỏ so với lương trả cho lập toàn bộ nhân công. Vì thế ngày nay, vấn đề hoạt động rất ít khi được chú ý nhiều.

Tuy nhiên vẫn có những trường hợp mà hiệu suất hoạt động được đặt lên tiên quyết. Những thành phần thường xuất hiện trên mọi trang tốt hơn nên dùng Webpart. Ngay cả với những trang có lượng truy cập thấp. Một ví dụ khác, khi xây dụng một thành phần có chức năng lấy các đường dẫn tương đối và tăng khả năng tạo cache hợp lý. Nó sẽ được tạo ra nhờ Webpart chứ không phải là User Control. Vì nó được load ra ít nhất 2 lần trong một trang – 1 trong header và 1 trong footer. Thành phần core này được sử dụng để đảm bảo hiệu suất hoạt động của Site mặc cho sử dụng một User Control sẽ dễ dàng hơn.

Cơ chế tích hợp

Xem xét cuối cùng là Webpart phải dựa vào cấu hình của mẫu thiết kế. Nói cách khác, chúng ta nên tạo ra một ứng dụng cho phép lấy nội dung từ URL hơn là tạo ra từng Webpart riêng biệt cho từng URL được gọi đến. Cấu hình cơ bản này rất hữu ích trong việc giảm code trùng lặp vào nâng cao giải pháp tổng thể.

Với Smartpart(Xem phần 1), có một vấn đề đó là quản lý cách thức mà thông tin được đẩy vào cho User Control. Giải pháp đó là tạo một đối tượng để chứa Control hoặc là tạo ra lớp con của SmartPart để thêm vào khải năng đẩy thông tin vào thuộc tính từ Sharepoint, Câu truy vấn từ URL hay là từ FORM POST. Điều này cho phép bạn cân bằng các tính năng của SharePoint và không cần tạo ra các liên kết trực tiếp giữa Control và Sharepoint.

Ví dụ, User Control có một thuộc tính Public để chứa ID của bản ghi (record) hiện tại. Những trang nào mà có ID cho bản ghi hiện tại lấy ra từ Sharepoint sẽ lấy được nó vì đó là thuộc tính Public. Nó có thể đẩy ID đó vào thuộc tính public của User Control. Điều này cho phép User Control không bị dính chặt với Sharepoint mà vẫn tận dụng được các tính năng của Sharepoint.

Kết luận

Như vậy, hầu hết những quan điểm cho rằng viết một chức năng cho Sharepoint là phải dùng Webpart là sai. Thích hợp hơn là chúng ta sử dụng ASP.NET user Control để tân dụng chúng trong Sharepoint bằng những kỹ thuật như là SmartPart.

I enjoy tinkering with both Java and C# and publish a lot of my source on this blog under a very liberal open-source license.

I have wondered, however, what I would do if I had to protect a commercial program written in either of the two. The obvious choice would be to purchase a professional obfuscation program that defeats most decompilers. Fair enough. Most of these work on the compiled intermediate code.

What, however, if I just wanted to put some mild protection into the compiled product? The mild protection I refer to would still allow the code to be decompiled back to source form, but the person decompiling would have to work hard to make use of the bulk of the code.

My solution was to try a simple shrouding utility.

Shrouding ( also referred to as fogging ) is a kind of source-level obfuscation that was somewhat popular years ago for C programs sold in source form. The programs would generally compile but would be unreadable enough that they would discourage someone from using portions of unlicensed code in other programs.

A lot of these source-level shroud utilities are language-aware and determine what variables, functions, methods, and classes are locally-scoped. The shroud utility then replaces these with generated identifiers.

Most shrouding utilities go a step further and obfuscate literal strings as well as rewriting flow-control constructs.

All I had intended to do was to change the locally-scoped identifier-names to something that my script generates.

My proof-of-concept is an AWK script called foggy.awk. foggy.awk replaces any identifier it finds beginning with two underscore characters with a new identifier containing the prefix “i_” and a sequentially generated number.

This means that in my code, I have to observe a coding convention. I will have to prefix the name of any identifier that should be shrouded with two underscores.

First, here’s the shrouding script:

foggy.awk

# Foggy.awk
# A source-code shrouding utility.
# Replace any "identifier" beginning with __ with a sequentially-
# numbered new identifier
#
# License: MIT / X11
# Copyright (c) 2009 by James K. Lawless
#
# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associated documentation
# files (the "Software"), to deal in the Software without
# restriction, including without limitation the rights to use,
# copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following
# conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
# OTHER DEALINGS IN THE SOFTWARE.
#
BEGIN {
   legal="abcdefghijklmnopqrstuvwxyz";
   legal=legal "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
   legal=legal "_0123456789" ;
   id_counter=0;
   id_list["__"]="__";
}
{
   state=0;
   s="";
   for(i=1;i<=length($0);i++) {
      c=substr($0,i,1);
      if(state==0) {
         if(c=="_") {
            state=1;
         }
         else {
            s=s c;
         }
      }
      else {
         if(state==1) {
            if(c=="_") {
               state=2;
               id="__";
            }
            else {
               s=s "_" c;
               state=0;
            }
         }
         else {
            # state == 2
            if(index(legal,c)<1) {
               if(id_list[id]=="") {
                  tmp_id="i_" id_counter;
                  id_counter++;
                  id_list[id]=tmp_id;
               }
               s=s id_list[id];
                  # decrement the index to forget the current
                  # character we're looking at
               i--;
               state=0;
            }
            else {
               id=id c;
            }
         }
      }
   }
   if(state==0) {
      printf("%s\n",s);
   }
   else {
      if(state==1) {
         printf("%s_\n",s);
      }
      else {
         if(state==2) {
            if(id_list[id]=="") {
               tmp_id="i_" id_counter;
               id_counter++;
               id_list[id]=tmp_id;
            }
            printf("%s%s\n",s,id_list[id]);
         }
      }
   }
}

As a side note, I have compiled the above script with the Thompson Automation AWK (TAWK) compiler for Windows into the exe foggy.exe available in the foggy.zip file referenced at the end of this post.

Unfortunately, TAWK is no longer commercially available. I reviewed this compiler years ago in Dr. Dobbs Journal. ( See Examining the TAWK Compiler, DDJ May ‘97 here: http://www.ddj.com/architect/184410193 …)

I also tested with GNU GAWK for Windows.

I would have preferred to use a regular expression with captured groups, but the AWK tools I have do not support those sorts of regex features. This likely would have been a smaller Perl script, but I wanted to try it in AWK. The necessary parser state transitions didn’t seem to be too deep, so I gave it a go.

To use the above script either type:

gawk -f foggy.awk < inputfle > outputfile

...or, if you're using foggy.exe

foggy.awk < inputfle > outputfile

Let's first take a look at a Java program that now contains shroud-ready identifiers. I took the source from MicroHttp1.java from my post here: http://jimlawless.wordpress.com/2009/08/23/tracing-xslt-with-a-tiny-java-web-server/

// MicroHttp1
// A small , specialized web server in Java
//
// License: MIT / X11
// Copyright (c) 2009 by James K. Lawless
// jimbo@radiks.net http://www.radiks.net/~jimbo
// http://www.mailsend-online.com
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.

import java.io.*;
import java.net.*;
import java.util.Date;

public class MicroHttp1Obf {
   public static void main(String[] __args)
      throws IOException {
      ServerSocket __serv;
      Socket __s;
      String __str;
      PrintWriter __pw;
      BufferedReader __br;
      __serv=new ServerSocket(80);
      System.out.println("Micro HTTP Server v 0.1");
      System.out.println();
      for(;;){
         __s=__serv.accept();
         __br=new BufferedReader(
            new InputStreamReader(
               __s.getInputStream()));
         for(;;) {
            __str=__br.readLine();
            System.out.println(__str);
            if( ! __br.ready())
               break;
         }
         System.out.println();
         __pw=new PrintWriter(
            __s.getOutputStream(), true);

         __pw.print("HTTP 200 OK\r\n");
         __pw.print("Content-type: text/html\r\n\r\n");
         __pw.print("<html><head /><body>");
         __pw.print("Current date/time " + new Date());
         __pw.print("</body></html>");
         __pw.close();
      }
   }
}

Note that I had to change the class definition to what I would be targetting for my output filename, since the main Java class and source filename prefix must match.

There are lots of underscores now in this short script. Here's the shrouded output:

// MicroHttp1
// A small , specialized web server in Java
//
// License: MIT / X11
// Copyright (c) 2009 by James K. Lawless
// jimbo@radiks.net http://www.radiks.net/~jimbo
// http://www.mailsend-online.com
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.

import java.io.*;
import java.net.*;
import java.util.Date;

public class MicroHttp1Obf {
   public static void main(String[] i_0)
      throws IOException {
      ServerSocket i_1;
      Socket i_2;
      String i_3;
      PrintWriter i_4;
      BufferedReader i_5;
      i_1=new ServerSocket(80);
      System.out.println("Micro HTTP Server v 0.1");
      System.out.println();
      for(;;){
         i_2=i_1.accept();
         i_5=new BufferedReader(
            new InputStreamReader(
               i_2.getInputStream()));
         for(;;) {
            i_3=i_5.readLine();
            System.out.println(i_3);
            if( ! i_5.ready())
               break;
         }
         System.out.println();
         i_4=new PrintWriter(
            i_2.getOutputStream(), true);

         i_4.print("HTTP 200 OK\r\n");
         i_4.print("Content-type: text/html\r\n\r\n");
         i_4.print("<html><head /><body>");
         i_4.print("Current date/time " + new Date());
         i_4.print("</body></html>");
         i_4.close();
      }
   }
}

There are really only about five shrouded identifiers in this program. I suppose someone who really wanted to work at it could perform global search-and-replace operations to change them into something meaningful as they analyze the code.

Let's try something a little larger that has more local identifiers. For this next test, I took the C# source code from my command-line Twitter client Twimmando. See: http://jimlawless.wordpress.com/2009/05/24/twimmando-a-command-line-twitter-client/

Here's the shroud-ready source:

// Twimmando - a command-line Twitter client

// License: MIT / X11
// Copyright (c) 2009 by James K. Lawless
// jimbo@radiks.net http://www.radiks.net/~jimbo
// http://www.mailsend-online.com
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.

using System;
using System.Net;
using System.Text;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Web;

namespace Twimmando
{

   public enum __RequestMethod
   {
      __Get,
      __Post,
      __Head
   }
   class __Config
   {
      public __RequestMethod __Method;
      public string __Uri;
      public string __UserName;
      public string __Password;
      public string __PostData;
   }

   class __Twimmando
   {
      public static string __Version = "Twimmando v1.01 (obfuscated)";
      public static void Main(string[] __args)
      {
         __Config __config;
         try
         {
            __config=__processCommandLine(__args);
            if(__config.__Uri==null)
               Environment.Exit(1);
            __doHttpRequest(__config);
         }
         catch(Exception e)
         {
            Console.Error.WriteLine(e.ToString());
            Environment.Exit(1);
         }
         Environment.Exit(0);
      }

      public static __Config __processCommandLine(string[] __args)
      {
         int __i;
         __Config __config=new __Config();
         __config.__PostData="";
         __config.__Method=__RequestMethod.__Get;

         for(__i=0;__i<__args.Length;__i++) {
            if(string.Compare(__args[__i],"-head",true)==0) {
               __config.__Method=__RequestMethod.__Head;
            }
            else
            if(string.Compare(__args[__i],"-post",true)==0) {
               __config.__Method=__RequestMethod.__Post;
            }
            else
            if(string.Compare(__args[__i],"-uri",true)==0) {
               __config.__Uri=__args[++__i];
            }
            else
            if(string.Compare(__args[__i],"-u",true)==0) {
               __config.__UserName=__args[++__i];
            }
            else
            if(string.Compare(__args[__i],"-p",true)==0) {
               __config.__Password=__args[++__i];
            }
            else
            if(string.Compare(__args[__i],"-f",true)==0) {
               if(__config.__PostData.Length>0) {
                  __config.__PostData+="&";
               }
               __config.__PostData+=__args[__i+1]+"="+HttpUtility.UrlEncode(__args[__i+2]);
               __i+=2;
            }
         }
         if(__config.__Uri==null) {
            Console.WriteLine(__Twimmando.__Version + "\nby Jim Lawless (@lawlessGuy)");
            Console.WriteLine("Usage:\n\ttwimmando [options]\nWhere options are:");
            Console.WriteLine("   -uri resourceURI   ; such as /statuses/public_timeline.xml");
            Console.WriteLine("   -u username        ; Twitter password");
            Console.WriteLine("   -p password        ; Twitter user name");
            Console.WriteLine("   -head              ; send HTTP HEAD request, default is GET");
            Console.WriteLine("   -post              ; send HTTP POST request, default is GET");
            Console.WriteLine("   -f name value      ; add POST data name/value pair to request");
         }
         return __config;
      }

      public static void __doHttpRequest(__Config __config)
      {

         HttpWebRequest __webRequest;
			HttpWebResponse __webResponse;
         Uri __uri=new Uri("http://twitter.com" + __config.__Uri);
			__webRequest = (HttpWebRequest)HttpWebRequest.Create(__uri);
         if(__config.__Password!=null) {
            __webRequest.Credentials = new NetworkCredential(__config.__UserName, __config.__Password);
         }

	 __webRequest.UserAgent = __Twimmando.__Version;
         if(__config.__Method==__RequestMethod.__Post) {
            __webRequest.Method = "POST";
               // remove Expect header
            __webRequest.ServicePoint.Expect100Continue = false;
            __webRequest.ContentType="application/x-www-form-urlencoded";
            __webRequest.ContentLength = __config.__PostData.Length;
            StreamWriter __sOut=new StreamWriter(__webRequest.GetRequestStream(),System.Text.Encoding.ASCII);
            __sOut.Write(__config.__PostData);
            __sOut.Close();
         }
         else
         if(__config.__Method==__RequestMethod.__Head) {
            __webRequest.Method="HEAD";
         }
	 __webResponse = (HttpWebResponse)__webRequest.GetResponse();
         if(__config.__Method==__RequestMethod.__Head) {
            Console.WriteLine(__webResponse.Headers.ToString());
         }
         else {
            Stream __stream = __webResponse.GetResponseStream();
            StreamReader __streamReader =
               new StreamReader(__stream, Encoding.ASCII);
            Console.WriteLine(__streamReader.ReadToEnd());
         }
         __webResponse.Close();
      }
   }
}

Here's the encoded result:

// Twimmando - a command-line Twitter client

// License: MIT / X11
// Copyright (c) 2009 by James K. Lawless
// jimbo@radiks.net http://www.radiks.net/~jimbo
// http://www.mailsend-online.com
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.

using System;
using System.Net;
using System.Text;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Web;

namespace Twimmando
{

   public enum i_0
   {
      i_1,
      i_2,
      i_3
   }
   class i_4
   {
      public i_0 i_5;
      public string i_6;
      public string i_7;
      public string i_8;
      public string i_9;
   }

   class i_10
   {
      public static string i_11 = "Twimmando v1.01 (obfuscated)";
      public static void Main(string[] i_12)
      {
         i_4 i_13;
         try
         {
            i_13=i_14(i_12);
            if(i_13.i_6==null)
               Environment.Exit(1);
            i_15(i_13);
         }
         catch(Exception e)
         {
            Console.Error.WriteLine(e.ToString());
            Environment.Exit(1);
         }
         Environment.Exit(0);
      }

      public static i_4 i_14(string[] i_12)
      {
         int i_16;
         i_4 i_13=new i_4();
         i_13.i_9="";
         i_13.i_5=i_0.i_1;

         for(i_16=0;i_16<i_12.Length;i_16++) {
            if(string.Compare(i_12[i_16],"-head",true)==0) {
               i_13.i_5=i_0.i_3;
            }
            else
            if(string.Compare(i_12[i_16],"-post",true)==0) {
               i_13.i_5=i_0.i_2;
            }
            else
            if(string.Compare(i_12[i_16],"-uri",true)==0) {
               i_13.i_6=i_12[++i_16];
            }
            else
            if(string.Compare(i_12[i_16],"-u",true)==0) {
               i_13.i_7=i_12[++i_16];
            }
            else
            if(string.Compare(i_12[i_16],"-p",true)==0) {
               i_13.i_8=i_12[++i_16];
            }
            else
            if(string.Compare(i_12[i_16],"-f",true)==0) {
               if(i_13.i_9.Length>0) {
                  i_13.i_9+="&";
               }
               i_13.i_9+=i_12[i_16+1]+"="+HttpUtility.UrlEncode(i_12[i_16+2]);
               i_16+=2;
            }
         }
         if(i_13.i_6==null) {
            Console.WriteLine(i_10.i_11 + "\nby Jim Lawless (@lawlessGuy)");
            Console.WriteLine("Usage:\n\ttwimmando [options]\nWhere options are:");
            Console.WriteLine("   -uri resourceURI   ; such as /statuses/public_timeline.xml");
            Console.WriteLine("   -u username        ; Twitter password");
            Console.WriteLine("   -p password        ; Twitter user name");
            Console.WriteLine("   -head              ; send HTTP HEAD request, default is GET");
            Console.WriteLine("   -post              ; send HTTP POST request, default is GET");
            Console.WriteLine("   -f name value      ; add POST data name/value pair to request");
         }
         return i_13;
      }

      public static void i_15(i_4 i_13)
      {

         HttpWebRequest i_17;
			HttpWebResponse i_18;
         Uri i_19=new Uri("http://twitter.com" + i_13.i_6);
			i_17 = (HttpWebRequest)HttpWebRequest.Create(i_19);
         if(i_13.i_8!=null) {
            i_17.Credentials = new NetworkCredential(i_13.i_7, i_13.i_8);
         }

	 i_17.UserAgent = i_10.i_11;
         if(i_13.i_5==i_0.i_2) {
            i_17.Method = "POST";
               // remove Expect header
            i_17.ServicePoint.Expect100Continue = false;
            i_17.ContentType="application/x-www-form-urlencoded";
            i_17.ContentLength = i_13.i_9.Length;
            StreamWriter i_20=new StreamWriter(i_17.GetRequestStream(),System.Text.Encoding.ASCII);
            i_20.Write(i_13.i_9);
            i_20.Close();
         }
         else
         if(i_13.i_5==i_0.i_3) {
            i_17.Method="HEAD";
         }
	 i_18 = (HttpWebResponse)i_17.GetResponse();
         if(i_13.i_5==i_0.i_3) {
            Console.WriteLine(i_18.Headers.ToString());
         }
         else {
            Stream i_21 = i_18.GetResponseStream();
            StreamReader i_22 =
               new StreamReader(i_21, Encoding.ASCII);
            Console.WriteLine(i_22.ReadToEnd());
         }
         i_18.Close();
      }
   }
}

This shrouded program was much more difficult for me to read, as I used some local class definitions and used more local variables and methods than I had used in the sample Java program.

My conclusion?

Well, if I had to employ this method, I think I could grow into learning to deal with the added noise of the extra underscores in the source.

However, I still think that language-aware shrouding utilities would be much less painful to use.

The source and Windows executable file for foggy.awk can be downloaded in a single archive at:
http://www.mailsend-online.com/wp/foggy.zip

Save to del.icio.us
Digg it
Save to Reddit
Share on Facebook
Share on Twitter
More bookmarks

Unless otherwise noted, all code and text entries are Copyright © 2009 by James K. Lawless

Three days ago, I thought of implementing an application that would be able to track the things I spend my money on, my debts, and the debts of others to me.

I thought of implementing it as a web application but a thought stopped me in my tracks. Why not use C# as the front end and MySQL as the back end? That would be something new. I have not tried connecting C# (or anything else except JSP and PHP) to a database yet. Then and there I searched the web on how to connect C# to MySQL . Relatively easy. Soon, I was able to connect successfully and started coding the user interface. It was then that a big stumbling block came up.

In PHP, you do this to insert a new tuple into the database -> “insert into table1 values(‘constant’,'$variable’)”;
Thinking logically at first, I tried -> “insert into table1 values(var1,var2,var3)”; (No errors but wrong values)
After searching for a while, I tried …values(@var1,@var2,@var3); (Exception detected.T_T)

Just an hour ago, I came along a blog and I thought of the old way of inserting variables in SQL queries in PHP. String concatenation. “This is it”,I thought to myself.

I tried this at first: “INSERT INTO expenses values (” + expense + “,” + amount + “,” + date + “);”;
(Looks great right? Error! Column name is invalid)
Thinking…thinking…Supposedly right but very wrong. I started to consult my friend Google again and I came across a forum that says in order to insert a string variable into the query, there should be single quotes surrounding the variable name.Hmmm..
Tried this (note the red single quotes): “INSERT INTO expenses values (‘ ” + expense + “ ‘,” + amount + “,‘ ” + date + ” ‘);”;  (and it worked perfectly!)=)