.NET

Tulsa Visual Studio 2008 InstallFest

dbottjer — Tue, 04 Dec 2007 08:08:00 GMT

Tonight (12/03/2007) I attended the Tulsa, OK .NET User Group's Visual Studio InstallFest organized by David Walker. The event had an amazing turnout with over 150 people in attendance. We had a great time networking and installing Visual Studio 2008.

PEX Dynamic Test Generation

dbottjer — Wed, 14 Nov 2007 17:16:29 GMT

Found this project, http://research.microsoft.com/Pex/ from MS Research which apparently dynamically generates tests and code analysis during active development. Interesting way to enforce code quality and just prove requirements are being met.

Mind Mapping with Bookvar

dbottjer — Thu, 08 Nov 2007 13:29:00 GMT

Bookvar http://www.bookvar.net/Default.aspx is a free Mind Mapping Windows Application built on the .NET 3.5 Beta Framework. It highlights some amazing UI features available in WPF. The application can be easily extended via add-ins. The development team plans to make monthly releases.

ASP.NET Debug=true Performance Considerations

dbottjer — Wed, 10 Oct 2007 13:36:00 GMT

I'm sure, like me, you've seen plenty of production web.config files with debug=true set. Most senior ASP.NET developers will recognize that debug should be set to false for the production build. However, this small detail is often over looked. So what does this setting really do and does it have any significant impact on a production site?

When debug is set to true, the following occurs:

Pages are not batch compiled.
Pages do not time out. When a problem occurs, such as a problem with a Web service call, the Web server may start to queue requests and stop responding.
Additional files are generated in the Temporary ASP.NET Files folder.
The System.Diagnostics.DebuggableAttribute attribute is added to generated code. This causes the CLR to track extra information about generated code, and it also disables certain optimizations.

Source of Information: http://msdn2.microsoft.com/en-us/library/ms998549.aspx

Thoughts On Recursion

dbottjer — Tue, 10 Jul 2007 10:45:00 GMT

Recursion is a computer science concept in which a method / function essentially calls itself until some condition is met. Recursion can be an elegant solution to some logic problems. However, I believe there are some potential dangers in using recursion that should carefully be consider. Recursion is not an impossible concept to grasp it is just one that takes some thought. The skill level of those maintaining an application should be considered before implementing recursion as it is a more advanced programming concept and could lead to serious performance issues of not implement correctly.

namespace RecursionTest
{
    class Program
    {
        static void Main(string[] args)
        {
               System.Console.WriteLine(calcFactorial(4));
               System.Console.ReadLine();	
         }


        static int calcFactorial(int n)
        {
            return n * calcFactorial(n - 1);
        }

    }
}

Did you spot the bug in the code above? The code never stops when the factorial is complete resulting in an infinite loop. To fix the code we need to add a simple constraint or check.

namespace RecursionTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(calcFactorial(4));
            Console.ReadLine();
        }


        static int calcFactorial(int n)
        {
            if (n == 1)
            {
                return 1;
            }
            else
            {
                return n * calcFactorial(n - 1);
            }
        }
    }
}

The recursive code above is very clean however as demonstrated it is easy to forget the constraint and introduce an infinite loop. I would also like to point out that from a performance standpoint recursion may not be the best choice. It is often faster to use a looping structure where possible. Finally, one must consider the impact recursion has on the managed stack in .NET. Basically the deeper a thread's stack becomes the more difficult it becomes for the Garbage Collector to determine what should be collected and what is still in use.

Office Business Applications Architecture Talk With Colin Cole

dbottjer — Thu, 24 May 2007 23:27:00 GMT

The following conversation is a conversation with Microsoft Financial Services Sr. Architect Colin Cole discussing Office Business Applications (OBA). This is a new type of blog post for me and a Drowning In Technical Debt first. I hope to conduct similar conversations in the future. Finally, I would like to thank Colin for making time to have this conversation with me.

dbottjer says: So I figured a good place to start would be with a definition. What is OBA? I did some research and here is what I came up with. Office Business Applications (OBA) use the Microsoft Office Suite of programs (Outlook, Word, Excel, etc) as a presentation layer for connecting line of business applications and executing business processes.

Colin Cole says: Cool, I have a few more things.

dbottjer says: Ok great.

Colin Cole says: OBA is kind of the centerpiece of what we call a "people ready" solution.

Colin Cole says: It’s really about designing a solution to give the end user more control and agility to interact with the application. Rather than having the IT defined screens with text boxes and validation.

dbottjer says: The user has more control to personalize.

Colin Cole says: You get instead something that brings data down to the tools you're familiar with (as you state), but also have server piece as well and that's where office server (SharePoint) comes in. By exposing data through something like a SharePoint the business user can define their own reports bring the data down to a cube and open it up in excel. Slice and Dice. Create a dashboard.

dbottjer says: Right

Colin Cole says: Define their own KPI's. Etc. So like you state -- leveraging familiar tools, but also interacting with the solution data as appropriate for their role.

dbottjer says: So this leads to the Problem. I thought that a good problem definition is: a fundamental inconsistency between how business systems work and how people work.

Colin Cole says: Agreed

dbottjer says: Basically applications today are very rigid

Colin Cole says: Absolutely, take an investment scenario for example. The investor interacts with the canned application to analyze their portfolio. But there's always 5-6 things they want to know to make business decisions that aren't available. So what do they do? They call IT and ask for a new report. 2 months later they get their report. But by that time the need is totally different.

dbottjer says: Exactly.

Colin Cole says: So the reality is they don't even bother....and just create their own one-off spreadsheets that aren't reused, etc.

dbottjer says: So if they have an export feature they could export to Excel and do some quick processing there.

dbottjer says: But that is an one-off.

Colin Cole says: Right.

dbottjer says: So the idea of OBA is just to allow users to work in tools like Excel to begin with an augment excel with the missing services necessary for the problem domain.

Colin Cole says: Right, as well as interacting with dashboard/reporting type functionality bringing down tasks into Outlook, --like I showed you guys with our lending solution. Stuff like that.

dbottjer says: I guess this leads us to why use OBA? OBA's offer a familiar interface – Most business users are familiar with at least one or more programs within the Microsoft Office Suite. For example, Outlook is commonly used groupware that remains open throughout the business day on many corporate desktops. It would seem like a win-win situation to take advantage of a program that users are already familiar with and that is running on their desktops. Excel.

Colin Cole says: Exactly, why not plug a CRM tool into Outlook, since the sales folks are already familiar with the paradigm?

dbottjer says: OBA integrates line of business applications such as Enterprise Resource Planning (ERP), Customer Relationship Management (CRM), and Supply Chain Management (SCM) in a presentation layer the user is already familiar with and productive in. For example, a sales associate may depend heavily on Outlook to communicate with his/her clients. The associate keeps To Do lists within Outlook and a calendar of all meetings. Integrating the sales associate’s Outlook with CRM would centralize all the company’s customer information. This would give the sales associate a place to add customer notes and perhaps a way to look up additional customer information such as support cases.

Colin Cole says: Exactly.

dbottjer says: So it seems like an efficient model for developing line of business applications?

Colin Cole says: Right, obviously not for everything, but some % of apps it's a better fit.

dbottjer says: Something else I noticed is that OBA is a great reuse story. For example, to implement an OBA solution you use an office product like Word, Excel, Outlook, SharePoint, etc. You also can use existing web services. Furthermore, you use VSTO and .NET.

Colin Cole says: InfoPath plays nicely as well. Especially the server forms stuff. Very cool, each InfoPath form can have C# Code Behind, just like aspx. It makes for a simple model to build professional looking web pages.

dbottjer says: So OBA is a culmination of technologies to provide a business solution designed for how people work. It seems like OBA's have the potential to have a big impact in the line of business application space.

.NET 2.0 FailFast Method

dbottjer — Wed, 09 May 2007 01:07:00 GMT

[Dave] copied me on an email a few months back from a colleauge regarding the FailFast method. This method was added to the .NET 2.0 framework and basically terminates a process without executing the any application Try-Finally or finalizer code. Additionally, this method creates a memory dump for your application and writes a log entry to the Windows Application Event Log.

WPF Views for CAB

dbottjer — Thu, 12 Apr 2007 09:39:00 GMT

Found this project http://www.codeplex.com/wpfcab on codeplex. It strives to add WPF Views to the CAB. This solution doesn't use crossbow and isn't using interop with WinForms.

Delegate Timers In ASP.NET

dbottjer — Tue, 27 Feb 2007 12:45:00 GMT

Windows Services are similar to UNIX daemons. They are applications that start when Windows boots and continue running until Windows shuts down. A Windows Service might be used to implement a timer that continually polls a source looking for new data. When new data is found an import process might be kicked off. .NET has made developing Windows Services much easier than past methods. As mentioned above a Windows Service is an application and as such requires installation. In the remainder of this post I would like to propose an alternative to developing a Windows Services for cases when an ASP.NET Application has already been developed. Including code within the Global.ASAX of an ASP.NET application to replace the task a Windows Service would perform eliminates the need to deploy two separate applications. In a large corporate environment keeping deployments as simple as possible is generally a good idea. The following code demonstrates how a delegate based server side timer can be implemented within the Global.asax of an ASP.NET application.

using System;
using System.Collections.Specialized;
using System.Threading;
using System.Web;
using AIS.Configuration;

namespace AIS.Reporting
{
    public partial class Global : HttpApplication
    {
        #region Private Members
        private ReportingService reportingService;
        private int minutes = 1;
        private static Timer reportTimer;
        private int seconds = -1;
        private bool enableReportProcessing;
        #endregion

        #region Methods: Timer

        /// <summary>
        /// Creates the timer and sets the callback if it is enabled
        /// </summary>
        public void InitializeTimer()
        {
            NameValueCollection appSettings = DynamicConfigurationManager.AppSettings;
            enableReportProcessing = bool.Parse(appSettings["ReportTimerEnabled"]);
            seconds = int.Parse(appSettings["ReportTimerSecondsInterval"]);
            AutoResetEvent autoEvent = new AutoResetEvent(false);
            
            if (reportTimer == null && enableReportProcessing)
            {
                reportTimer = new Timer(new TimerCallback(reportTimer_Callback), autoEvent, Interval, Interval);
            }

        }

        /// <summary>
        /// Internal call back which is responsible for firing IJob.Execute()
        /// </summary>
        /// <param name="state"></param>
        private void reportTimer_Callback(object state)
        {
            ProcessReport();
        }

        public void ProcessReport()
        {
            if (reportingService == null)
            {
                reportingService = new ReportingService();
            }
                reportingService.ProcessReport();
        }

        

        #endregion

        protected int Interval
        {
            get
            {
                if (seconds > 0)
                    return seconds * 1000;
                return Minutes * 60000;
            }
        }

        #region Public Properities

        public int Minutes
        {
            get { return minutes; }
            set { minutes = value; }
        }

        public bool EnableReportProcessing
        {
            get { return enableReportProcessing; }
            set { enableReportProcessing = value; }
        }

        public bool IsRunningProcessReport
        {
            get { return isRunningProcessReport; }
            set { isRunningProcessReport = value; }
        }

        #endregion

        void Application_Start(object sender, EventArgs e)
        {
            InitializeTimer();
        }

    }
}

Visual Log Parser On Code Plex

dbottjer — Fri, 23 Feb 2007 11:11:00 GMT

Microsoft has a nifty command line utility known as Log Parser which can parse many common log file formats such as IIS, SMTP, and FTP logs. I found this http://www.codeplex.com/visuallogparser project on Code Plex which is a Smart Client front end to the Log Parser. Visual Log Parser is a great way to query event logs, IIS Logs, etc.