C#

Automated Web Testing with Visual Studio 2008

dbottjer — Tue, 28 Apr 2009 06:32:03 GMT

Tulsa Developers User Group | Automated Web Testing with Visual Studio 2008 (Review)

Corey Roth presented tonight on automated web testing with Visual Studio 2008 at the Tulsa Developers User Group. Visual Studio can be used to record an action such as logging into a web application. Alternatively, users can inspect screen values for specific results. The test would pass if the expect value is present and fail if the value is missing. Visual Studio must be installed to execute the tests.

A tests project actually generates .NET Code (C# or VB.NET). The tool can also be used to show raw header information and cookies. One drawback is that only Internet Explorer is supported.

Additional Information:

Follow me on twitter @dbottjer

Technorati Tags: Web Automated Tested,Tulsa Developers User Group

REGULAR EXPRESSIONS WITH EXpresso

Dennis Bottjer — Thu, 15 Jan 2009 06:09:06 GMT

Issue:

Regular Expression are quite power especially for validation purposes. Classic examples include password and email validation. However, regular expressions are usually something developers get to work then forget about. I don't work with regular expression everyday so I don't bother memorizing the syntax. So when I do need to use a regular expression in code I usually end up searching the web for an example.

Solution:

A coworker here at SpringPoint Technologies turned me on to Expresso, a free regular expressions authoring tool.

Technorati Tags: Regular Expressions,Expresso

Manipulating SharePoint Groups With Code

Dennis Bottjer — Thu, 09 Oct 2008 08:05:43 GMT

SPWeb.Groups and SPWeb.SiteGroups

WSS 3.0 deprecates the site group concept used in WSS 2.0. As a result manipulating groups and security objects through the object model can be less than obvious.

For Example, a developer may try to add a group to a sub site (SPWeb) using this syntax SPWeb.Groups.Add(Group Name). However, in WSS 3.0 and MOSS 2007 this code will result in the following error:

“You cannot add a group directly to the Groups collection. You can add a group to the SiteGroups collection.”

To resolve this error and create a group use the following object model syntax: SPWeb.SiteGroups.Add(). This code will create a new group at the site collection level. Groups created at the site collection level are basically the same as “Cross Site Groups” from WSS 2.0.

Note: All sub sites that are inheriting permissions from a parent site will see the groups added using SPWeb.SiteGroups.Add() when iterating through the SPWeb.Groups collection.

Ref: http://msdn.microsoft.com/en-us/library/ms469194.aspx

Associating a Group with a Site

It is important to realize that groups are never really “Added” to sites (SPWebs) but are instead associated. For example, if you have created a sub site that does not inherit permissions from its parent and you would like to “Add” a project manager group to that site you would use the following code.

   1: // Get a reference a group by name.

   2: SPGroup oGroup = webSite.SiteGroups[groupName];

3:

   4: // Get the role definition to assign ex: Full Control

   5: SPRoleDefinition oRole = webSite.RoleDefinitions[roleDefinition];

6:

   7: // Create the role assignment object

   8: SPRoleAssignment oRoleAssignment = new SPRoleAssignment(oGroup);

9:

  10: // Add the role definition to the role assignemnt.

11:

  12: // Assign the specific permission to the security principal for this role assignemnt.

  13: oRoleAssignment.RoleDefinitionBindings.Add(oRole);

14:

  15: // Add the role assignment to the web

  16: webSite.RoleAssignments.Add(oRoleAssignment);

17:

  18: webSite.Update();

This code associates a site collection (Cross Site) Group with a SPWeb and assigns a role definition such as “Full Control.” With the code discussed in this post we could create a group, then give that group full control to a sub site.

Technorati Tags: SharePoint Security,SPWeb.Groups and SPWeb.SiteGroups,Adding SharePoint Groups

Tampa 2007 Code Camp OBA Slides

dbottjer — Wed, 18 Jul 2007 12:29:00 GMT

I want to thank everyone who attended my session on Saturday. I had been sick all week and was still feeling quite run down but we had some great discussions. Office Business Applications (OBA) are really an excited way to look at developing or extending line-of-business applications. As promised here are my slides and some important OBA links.

Download Tamp 2007 Code Camp OBA Presentation
Supply Chain Management OBA Reference Pack
Loan Origination Reference Pack

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.

Understanding Composite Application Block Series

dbottjer — Tue, 15 May 2007 06:55:00 GMT

We've been using the Composite Application Block (CAB) and Smart Client Software Factory (SCSF) since they first emerged. Most of my focus has been on the middle tier and service layer which our smart client front ends consume. However, recently we have needed more manpower building smartparts. As result I've been refreshing my knowledge of the CAB and SCSF. I found found a great blog series http://geekswithblogs.net/kobush/category/3702.aspx on understanding the cab. The series does a great job defining the CAB terminology and explaining the basic architecture.

DoNotExposeGenericLists recommends Collection<T> over List<T>

dbottjer — Wed, 09 May 2007 18:55:00 GMT

DoNotExposeGenericLists is a Code Analysis rule exposed within Visual Studio when List<T> is publically exposed. For example, List<T> may be exposed through properties, methods, parameters, etc. Why does DoNotExposeGenericLists recommend that I expose Collection instead of List? [David Kean] explains that Collection<T> is the better choice b/c it exposes 4 overidable methods. The methods are ClearItems, InsertItem, RemoveItem and SetItem. Events can be raised from within these four methods to provide a notification when changes are made to the Collection.

.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.

Web Services and UTF8Encoded ByteArrays

dbottjer — Tue, 01 May 2007 10:06:00 GMT

Our business partner began reporting all bullet points were being converted to question marks during the archiving of Word Docs. An early hunch that perhaps our FTP component was defaulting to ASCII transfer mode instead of Binary proved incorrect. With this option ruled out we knew our electronic document repository was properly receiving both the control file and the Word Doc. We began to suspect the web service exposed by our application which returns a document and metadata for archiving. We were using a byte array to store, in this case, the word document and write it to the http response stream. However, we were not specifying the encoding type which was our fatal mistake.

1: StringWriter sw = new StringWriter();

   2:  XmlTextWriter xw = new XmlTextWriter(sw);

3:

   4:  // Save Approval Document to Text Writter.

   5:  doc.WriteTo(xw);

6:

   7:  // Added this line to specify encoding and resolve bullet point issue.

   8:  UTF8Encoding encoding = new UTF8Encoding();

9:

  10:  // Convert Approval Document To Byte Array.

  11:  byte[] docAsBytes = encoding.GetBytes(sw.ToString());

12:

  13:  vvDoc.FileBinary = docAsBytes;