2. TABLE OF CONTENTS
• Business Tier Object Framework………………………………..…...3
• Library Phase 1: Windows Forms & Business Layer……………..…9
• Library Phase 2: ADO.NET 3.5 Data Access & Entity Layer….......13
• Library Phase 3: ASP.NET Web Application………….…………...20
• Resumé…...…………………………………………………………32
ABOUT
MICHAEL CUMMINGS
Seattle, WA 98103
(406) 546-0952
michael.cummings@setfocus.com
SUMMARY
Highly motivated C# Software Developer/Programmer with experience using object oriented design
techniques and programming languages, including Microsoft .NET Technologies. Designed, developed and
documented multi-tier applications with Web and database integration. Demonstrated leadership abilities
and team work skills as well as ability to accomplish tasks under minimal direction and supervision.
http://www.linkedin.com/in/mikewcummings
TECHNICAL SKILLS
Programming Languages:
C#, XML, HTML, CSS, JavaScript, T-SQL
.NET Skill Set:
.NET Framework 3.5 and Common Type System, ASP.NET, SilverLight, AJAX, XAML, WPF, WCF, ADO.NET,
LINQ, .NET Class Libraries, Web Services
Databases:
MS SQL Server 2008
Software:
Visual Studio 2008
2
3. Business Tier Object Framework – Retail Services
Overview:
Developed Business Tier components for Retail Services Company. Two primary assemblies were constructed:
• Foundation.dll : Interface and Base Classes
• AppTypes.dll: Various Entity, Collection, and Exception classes
Project requirements included integrating new assemblies into existing object framework and verifying functionality
using detailed unit-testing. Business objects were required to implement .NET Framework interfaces and extend
.NET base classes whenever possible. Code required extensive documentation to improve maintainability. To
support this objective, the techniques utilized included Custom Attributes and XML Build Documentation.
Key Knowledge Components:
• Object Modeling of Business Entities
• Customizing Exception and Event Handling
• Improving Meta-Data using Custom Attributes
• Unit Testing using System.Reflection namespace
• Utilizing Strongly-Typed Generic Collections
• Implementing .NET Framework and Custom Interfaces
• Extending .NET Framework Base Classes
• Generating XML Release Build Documentation
Design Approach:
The approach to this project was to create functional business objects easily consumable by the presentation and data
access layer at runtime. Business objects supported custom binary and XML serialization for preserving application
state between sessions and communicating in a distributed environment. Whenever possible, custom objects were
developed by implementing .NET Base Classes and extending standard .NET Interfaces. Examples of this include
implementing .NET 2.0 Generic Interfaces such as IComparable<T>, IComparer<T> and standard interfaces such as
ISerializable. Usability and flexibility of objects was enhanced by providing intuitive operator overloading and
overriding base class methods such as Object.GetHashCode(). Furthermore, customized exception classes were built
to provide application specific error information and an EventLogger class was developed to register delegates to
customized collection modification events.
For proper integration and regression analysis, the code was unit-tested during development using test scenarios and
runtime reflection. To support future maintainability, code was commented using .NET XML documentation
generated on build as well as customized attributes viewable at runtime using reflection or via the MSIL Manifest
using ILDASM.exe.
3
4. - Foundation.dll -
Object Modeling of Business Entities, Implementing Custom & .NET Framework Interfaces
4
5. - AppTypes.dll -
Object Modeling of Business Entities, Implementing .NET Framework Interfaces, Utilizing Strongly-Typed
Generic Collections
5
6. - AppTypes.dll (cont.) -
Improving Meta-Data using Custom Attributes, Extending .NET Framework Base Classes
Customizing Exception and Event Handling, Extending .NET Framework Base Classes
6
8. - CODE SAMPLE -
Improving Meta-Data using Custom Attributes, Generating XML Release Build Documentation
namespace AppTypes
{
/// <summary>
/// The Product class is responsible for representing the various products and
services bought or sold by the company.
/// </summary>
[DeveloperInfo("Michael Cummings", Date="08/15/09", Title="developer")]
[CustomDescription("The Product class is responsible for representing the various
products and services bought or sold by the company.")]
[Serializable]
public class Product : IComparable<Product>
{
/// <summary>
/// Assignment overload for converting Product objects to legacy
DataAccess.ProductStruct's
/// </summary>
/// <param name="p">Product object to be converted</param>
/// <returns>Resulting DataAccess.ProductStruct</returns>
public static explicit operator DataAccess.ProductStruct(Product p)
{
return new DataAccess.ProductStruct()
{
CategoryID = p.CategoryID.ToString(),
ID = p.ID,
ProductName = p.ProductName,
QuantityPerUnit = p.QuantityPerUnit,
ReOrderLevel = p.ReOrderLevel,
SupplierId = p.SupplierID.ToString(),
UnitPrice = p.UnitPrice,
UnitsInStock = p.UnitsInStock,
UnitsOnOrder = p.UnitsOnOrder
};
}
...
8
9. Windows Forms Presentation & Business Layer – Library Phase 1
Overview:
Developed a Windows Forms-based front-end application to support the principal functions of a lending
library’s day-to-day operations including adding new members and checking books in and out. The front-end
interfaces with a SQL Server 2008 database via existing Data Access Layer assemblies. The following were
general requirements and provisions:
• Develop easily maintainable code that makes efficient use of database resources
• Provide sophisticated front-end validation logic to ensure data-integrity
• Construct an intuitive, functional interface which requires minimal training for users
Key Knowledge Components:
• Designing intuitive non-modal user-interface under ambiguous design guidelines
• Validating complex input using Regular Expressions
• Providing user input feedback via error providers
• Incorporating existing n-tier architecture for scalability
• Developing effective exception and error handling
• Binding of GridView controls at runtime to data source
• Segregating presentation logic from business rules by creating middle-tier Business layer
Design Approach:
The approach to this project was to build a functional UI with low cost of training and minimal development
time. Windows Forms was well-suited for this approach. The UI was organized based on the design
requirements set forth by the stakeholders. The front-end uses tabs to represent the discrete actions required by
the application with a global search function for pulling and viewing information on members. An intermediate
business layer was developed to enforce business rules and directly invoke data access layer components.
All user input is validated as controls leave focus which provides immediate feedback using error providers.
This design approach prevents needless and unsafe trips to the database with malformed data. Exceptions of
business and database logic (such as dependencies between members and checked-out items) are thrown at
underlying layers and handled by the front-end when the user submits the information. The exceptions are then
presented to the user in a meaningful non-technical format. Exceptions of these types were not checked on
losing control focus; this decision was made to improve scalability and database performance at the cost of
immediate feedback in some cases.
9
11. Use of Error Providers and Validators on Required Fields Providing Immediate Feedback
Front-End Handling and Presentation of Business & Data Access Tier Exceptions,
Data Presentation & Data Source Binding via GridView Objects
11
12. - CODE SAMPLE -
Business Layer Sample
/// <summary>
/// Check-out item based on unique ID to specified member
/// </summary>
/// <param name="memberID">Member ID</param>
/// <param name="isbn">ISBN</param>
/// <param name="copyNum">Copy Number</param>
/// <param name="expired">Output indicating Member expiration status</param>
/// <remarks>Will not checkout item if member ID has expired</remarks>
public void TryCheckOut(short memberID, int isbn, short copyNum, out bool expired)
{
if (GetMember(memberID).ExpirationDate >= DateTime.Now)
{
expired = false;
DataAccessLayer.CheckOutItem(memberID, isbn, copyNum);
}
else
expired = true;
}
/// <summary>
/// Returns items currently checked-out by member
/// </summary>
/// <param name="memberID">Member ID</param>
/// <param name="atLimit">Output indicating whether member has reached item checkout
limit</param>
/// <returns>ItemsDataSet</returns>
/// <remarks>Alerts with output parameter if member has reached checkout limit</remarks>
public ItemsDataSet GetItems(short memberID, out bool atLimit)
{
ItemsDataSet items = DataAccessLayer.GetItems(memberID);
atLimit = false;
if (items.Tables[0].Rows.Count > 3)
atLimit = true;
return items;
}
...
12
13. Windows Forms Data Access & Entity Layer – Library Phase 2
Overview:
Developed back-end data access & entity layers to support the lending library application from Phase 1. The
new assemblies utilize ADO.NET 3.5 technologies which replace the Phase 1 classic ADO.NET infrastructure.
In addition, SQL stored procedures were created to enhance database performance. The following were general
requirements and provisions:
• Design the Entity and Data Access Tiers
• Integrate with Existing Business and Presentation Layer w/o Modification
• Utilize LinqToSQL Object Model to Abstract Data Provider Code
Key Knowledge Components:
• Designing encapsulated layers and adhering to existing interfaces
• Creating ADO.NET 3.5 LinqToSQL object model of database
• Developing SQL stored procedures and views to enhance database performance
• Developing SQL test scripts to confirm stored proc error handling
• Implementing disconnected state access via DataSet objects
Design Approach:
The approach to this project was to incorporate .NET 3.5 technologies into the existing infrastructure and
improve database performance by developing robust stored procedures for common business processes. To
maximize efficiency, database state is presented to users via a disconnected model that returns the connection to
the database immediately after the data is queried. The .NET DataSet & GridView objects were implemented
to accomplish this. This approach drastically improved performance by minimizing database connections and
locks while reusing open connections across multiple, distinct function calls.
The library application connects to SQL Server 2008 and, as a result, a Linq-To-SQL object model was
developed to represent the database. The object model was based on views created in the database to represent
business objects, rather than the actual normalized table structure. Additionally, the object model incorporates
inheritance to emulate the database structure.
To improve performance through caching, SQL Server stored procedures were developed for the business
processes. Stored procedures include error handling which returns meaningful exceptions to upper layers when
database rules are violated. All stored procedures utilize transactions which rollback when errors are
encountered to ensure only atomic transactions occur which leave the database in a consistent state. To
facilitate testing, test scripts were developed to programmatically verify the correct behavior of the stored
procedures.
13
15. LINQ-To-SQL Object Model of Business Entities: DataContext Objects & Methods
Items DataSet based on LINQ-To-SQL Object Model for Disconnected State Access
15
16. - CODE SAMPLE -
Data Access Layer CheckOutItem call to SQL Stored Procedure using LINQ-To-SQL DataContext
/// <summary>
/// Checks out item
/// </summary>
/// <param name="memberNumber">Member ID to check-out item to</param>
/// <param name="isbn">ISBN to check-out</param>
/// <param name="copyNumber">Copy Number to check-out</param>
public void CheckOutItem(short memberNumber, int isbn, short copyNumber)
{
LibraryDataContext libraryDataContext = new LibraryDataContext();
try
{
libraryDataContext.CheckOutItem(memberNumber, isbn, copyNumber);
}
catch (SqlException ex)
{
//SQLExceptions with the number 50000 are user-generated
//This check needs to be performed before evaluating state
//property as a misleading error-code could be raised if a
//server-generated error state matched a user-defined error
//state in a stored proc
if (ex.Number == 50000)
{
switch (ex.State)
{
//State 1-3 are caused by a null argument in a required parameter
//Currently, these are all represented by a single error code
case 1:
case 2:
case 3:
throw new LibraryException(ErrorCode.CheckOutFailed, ex.Message, ex);
case 4:
throw new LibraryException(ErrorCode.NoSuchMember, ex.Message, ex);
case 5:
throw new LibraryException(ErrorCode.ExpiredMember, ex.Message, ex);
case 6:
throw new LibraryException(ErrorCode.ItemNotFound, ex.Message, ex);
case 7:
throw new LibraryException(ErrorCode.ItemNotLoanable, ex.Message, ex);
case 8:
throw new LibraryException(ErrorCode.ItemAlreadyOnLoan, ex.Message, ex);
default:
throw new LibraryException(ErrorCode.GenericException, "Unknown Application
Specific DB Error Occurred", ex);
}
}
else
throw new LibraryException(ErrorCode.GenericException, "General DB Error
Occurred", ex);
}
}
16
17. - CODE SAMPLE -
Checkout Item Stored Procedure
USE [library]
GO
/****** Object: StoredProcedure [dbo].[usp_CheckOutItem] Script Date: 10/08/2009
09:21:08 ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
--Checkout item
ALTER PROC [dbo].[usp_CheckOutItem]
@member_no SMALLINT = NULL,
@isbn INT = NULL,
@copy_no SMALLINT = NULL
AS
BEGIN TRY
--Check for null arguments in required inputs
IF @member_no IS NULL
RAISERROR ('MemberNo is null', 11, 1)
IF @isbn IS NULL
RAISERROR ('ISBN is null', 11, 2)
IF @copy_no IS NULL
RAISERROR ('Copy is null', 11, 3)
--Checks for existing member
IF NOT EXISTS
(SELECT * FROM member WHERE member_no = @member_no)
BEGIN
RAISERROR ('Member ID does not exist', 11, 4)
END
--Checks for existing member without expired library card
IF EXISTS
(SELECT * FROM memberView WHERE member_no = @member_no AND expr_date <
GETDATE())
BEGIN
RAISERROR ('Adult member expired', 11, 5)
END
--Checks for existing item
IF NOT EXISTS
(SELECT * FROM copy WHERE isbn = @isbn AND copy_no = @copy_no)
BEGIN
RAISERROR ('Item does not exist', 11, 6)
END
--Checks if item can be loaned
IF EXISTS
(SELECT * FROM item WHERE isbn = @isbn AND loanable = 'N')
BEGIN
RAISERROR ('Item is not loanable', 11, 7)
END
--Checks if item is already on loan
IF EXISTS
(SELECT * FROM copy WHERE isbn = @isbn AND copy_no = @copy_no AND on_loan =
'Y')
BEGIN
RAISERROR ('Item is already on loan', 11, 8)
END
BEGIN TRAN
17
18. --Insert loan entry
INSERT INTO loan (isbn, copy_no, title_no, member_no, out_date, due_date)
SELECT
@isbn,
@copy_no,
copy.title_no,
@member_no,
--Set checkout date to today
GETDATE(),
--Set due date in 2 weeks
DATEADD(DAY, 14, GETDATE())
FROM copy WHERE isbn = @isbn AND copy_no = @copy_no
--Update loan status to unavailable
UPDATE copy
SET on_loan = 'Y'
WHERE isbn = @isbn AND copy_no = @copy_no
COMMIT TRAN
--Return success
RETURN 0
END TRY
BEGIN CATCH
--Rollback all current transactions
IF @@TRANCOUNT >0
ROLLBACK TRAN
--Create variables for storing error information
DECLARE @ErrorMessage NVARCHAR(4000)
DECLARE @ErrorSeverity INT
DECLARE @ErrorState INT
--Store error information
SELECT @ErrorMessage = ERROR_MESSAGE(),
@ErrorSeverity = ERROR_SEVERITY(),
@ErrorState = ERROR_STATE()
--Rethrow error
RAISERROR (@ErrorMessage, @ErrorSeverity, @ErrorState)
--Return fail
RETURN -1
END CATCH
18
19. - CODE SAMPLE -
Data Access Layer LINQ Queries
/// <summary>
/// Retrieves collection of Items checked-out to specified member
/// </summary>
/// <param name="memberNumber">Member ID to check for loan items</param>
/// <returns>ItemsDataSet containing all current loan items</returns>
public ItemsDataSet GetItems(short memberNumber)
{
ItemsDataSet itemsDataSet = new ItemsDataSet();
LibraryDataContext libraryDataContext = new LibraryDataContext();
IQueryable<Item> query = null;
try
{
query = from item in libraryDataContext.Items
where item.MemberNumber == memberNumber
select item;
}
catch (Exception ex)
{ throw new LibraryException(ErrorCode.NoSuchMember, "Member not found", ex); }
try
{
foreach (var result in query)
{
itemsDataSet.Items.AddItemsRow(result.ISBN,
result.CopyNumber,
result.Title,
result.Author,
result.MemberNumber.Value,
result.CheckoutDate.Value,
result.DueDate.Value);
}
}
catch
{ //Null result set...do nothing }
return itemsDataSet;
}
/// <summary>
/// Retrieves a member
/// </summary>
/// <param name="memberNumber">MemberID to search for</param>
/// <returns>Member object of type Adult or Juvenile</returns>
public Member GetMember(short memberNumber)
{
LibraryDataContext libraryDataContext = new LibraryDataContext();
Member query = null;
try
{
query = (from member in libraryDataContext.Members
where member.MemberID == memberNumber
select member).Single();
}
catch (Exception ex)
{
throw new LibraryException(ErrorCode.NoSuchMember, "Member not found", ex);
}
return query as Member;
}
19
20. ASP.NET Web Application Front End – Library Phase 3
Overview:
Developed rich ASP.NET front-end application with re-use of Phase 2 data access, entity, & business layer
assemblies. Backwards compatibility and regression testing were performed to ensure any additions or
modifications to underlying layers did not break Phase 1 Windows Forms thick client. The following were
general requirements and provisions:
• Design ASP.NET Web-Based UI to interact with Phase 2 underlying architecture
• Integrate additional requested functionality without breaking Phase 1 Windows Forms client
• Enforce Forms-based authentication to protect access to data
Key Knowledge Components:
• Designing and developing attractive web-based UI
• Maintaining state using client-side and server-side strategies
• Implementing custom role-based security using Forms Authentication
• Reusing and extending existing underlying n-tier architecture
• Optimizing ASP.NET performance using Caching
• Integrated accessibility options to support diverse user base
Design Approach:
The approach to this project was to develop a rich ASP.NET web application to integrate with loosely coupled
existing n-tier architecture and to extend functionality as required. Extended functionality included additional
business layer and data access methods to query and update SQL Server 2008 Database. State is managed via
diverse client-side and server-side strategies including cookies, viewstate, query strings, session state, and
caching.
Web front-end was developed using modern standards-based design strategies. Markup was validated against
W3C XHTML Transitional guidelines and WCAG Priority 2 & Access Board Section 508 accessibility
requirements. Presentation logic was separated from markup using a primarily CSS-based Theme with light use
of Skins for specific server controls. This approached produced lean semantic XHTML markup to improve
code clarity, search engine parsing, and performance. Customized alpha-channel graphics were developed
using open source professional imaging tools (GIMP – GNU Image Manipulation Program). Additionally,
ASP.NET Master pages and User Controls were used to produce a consistent look and feel as well as maximize
maintainability and code re-use. Navigation and browsing context are maintained using bread-crumb and tree-
view functionality via global site map.
To improve performance, usability, and feedback response, asynchronous processing of requests was
implemented using AJAX partial-page postback strategies. In addition, the AJAX Toolkit was used to provide
a rich user interface such as dynamic calendar controls. Application response and load management were
improved through use of Caching to ensure frequently used resources were pre-compiled without sacrificing up-
to-date state representation.
To enforce security over an external network, the ASP.NET web application employed a Forms-based
authentication model with custom configured roles. To also improve security, global application error handling
is employed to redirect end-user generated errors to customized error pages which present helpful information
without compromising sensitive implementation details.
20
21. Project Structure:
Admin/ - All main content pages as well as custom user
controls. This folder is only accessible to authenticated
users with the “Librarian” role.
App_Code/ – Helper classes used throughout the
project
App_Data/ – Simple XML file which provides the
source data for selecting states in certain dropdown
boxes.
App_Themes /– Global style information. Design is
primarily CSS driven with some use of Skins for server
controls. Also contains all image files used throughout
the website
Bin/ – Compiled assemblies. This references the
underlying business, data access, and entities layer.
Also, this contains the AJAX Control Toolkit server
controls used to provide “rich” interface in certain areas
of the site.
MasterPage.aspx – Centralized common functionality
shared across site including “look-and-feel,”
navigation, and current user / logout operation
Web.sitemap – Data source for global navigation.
Global.asax – Used for application level error-handling
and redirection to custom error page Error.aspx
Default.aspx – Home page
web.config – Site configuration. Custom configured to
restrict access to admin folder and set global default
theme.
21
22. -Example Page-
Implementing custom role-based security using Forms Authentication
(Login Page – Option to remember user using cookie)
(Welcome Page – Current logged in user display and ability to log-out)
22
23. -Example Page-
ISBN Registry Management Interface
(Usage of GridView and DetailView Server Controls to display information to end-user)
23
24. -Example Page-
Checkout Book Processing
(Data Entry Page – Cross-Page Post to Confirmation Page)
(Confirmation Page – Displays Eligibility, User Detail, & Book Detail w/ Option to Cancel Operation)
24
25. -Detailed Walkthrough-
Search Member Page
This page allows Librarians to perform lookups based on Member ID. The page performs front-end Javascript
validation as well as server-side user-input and database validation (checking that the member exists). A query
string approach is used which rejects inappropriate values manually edited in the URL.
Member information is displayed when a valid ID exists. Juveniles are automatically upgraded to adults if they
are over 18 years of age and expired members have a button appear to renew their card. Librarians can view the
items on loan with overdue items highlighted in red. The library can check-in loan items directly from this
screen. The check-in process is performed asynchronously using a partial page postback. User “processing”
feedback is provided via a looping animation as the action is performed (shown below - it is a freeze-frame of
dots arranged in a circle).
The following sections will show “under-the-hood” code samples of the browser output below:
• Master Page
• Theme (CSS & Skin)
• Content Page
• User Control (Loans.ascx)
• C# Code-Behind
25
29. -Content Page -
The page contains:
• Semantic XHTML markup for non-interactive display elements
• Input validation, both server-side and client-side
• Custom user controls for displaying data
<%@ Page Title="Search Member" Language="C#" MasterPageFile="~/MasterPage.master"
AutoEventWireup="true" CodeFile="membersearch.aspx.cs" Inherits="membersearch" %>
<%@ Register src="../UserControls/Loans.ascx" tagname="Loans" tagprefix="uc1" %>
<%@ Register src="../UserControls/MemberStatus.ascx" tagname="MemberStatus"
tagprefix="uc2" %>
<asp:Content ID="Content1" ContentPlaceHolderID="PlaceHolderMain" Runat="Server">
<h1>Search for Member</h1>
<p>Enter the ID you would like to perform a search for. Current member status will be
displayed, along with
items currently on loan. <em>Remember the following:</em></p>
<div class="containerPane">
<ul>
<li>Loan items can be checked in</li>
<li>Overdue items on loan will be highlighted in yellow</li>
<li>Expired members will have a highlighted expiration and can be renewed</li>
<li>Juveniles who have reached 18 years of age are converted to adults</li>
</ul>
</div>
<div class="containerPane" >
<table class="form">
<tr>
<td>Member ID:</td>
<td>
<asp:TextBox ID="tbxID" runat="server" ></asp:TextBox>
<asp:RequiredFieldValidator ID="rfvID" runat="server"
ControlToValidate="tbxID" Display="Static"
ErrorMessage="Member ID required" ToolTip="Member ID required"
>*</asp:RequiredFieldValidator>
<asp:RangeValidator ID="rngvID" runat="server"
ControlToValidate="tbxID" Display="Static"
ErrorMessage="Member ID must be between 1 and 32,767" MaximumValue="32767"
MinimumValue="1" ToolTip="Member ID must be between 1 and 32,767"
Type="Integer" >*</asp:RangeValidator>
<asp:Button ID="btnSearch" runat="server" onclick="btnSearch_Click"
Text="Search" CssClass="leftMargin" /></td>
</tr>
</table>
</div>
<div class="containerPane">
<uc2:MemberStatus ID="ucMemberStatus" runat="server" />
</div>
<div class="containerPane">
<uc1:Loans ID="ucLoans" runat="server" />
</div>
<div class="containerPane">
<asp:ValidationSummary ID="SearchValidationSummary" runat="server"
HeaderText="Please correct the following errors:" />
</div>
</asp:Content>
29
31. - C# Code Behind -
The page contains code-behind for the Loans.ascx user control (Master & Content pages excluded):
• Highlight operation for overdue items on GridView_DataBound event
• Check-in operation for GridView_RowCommand event
using System;
...
/// <summary>
/// Displays Loan Information
/// </summary>
/// <remarks>uses query string</remarks>
public partial class Loans : System.Web.UI.UserControl
{
/// <summary>
/// Performs highlight operations
/// </summary>
/// <param name="sender">object sender</param>
/// <param name="e">event arguments</param>
protected void LoanGridView_DataBound(object sender, EventArgs e)
{
int DueDateCellIndex = 5;
foreach (GridViewRow row in LoanGridView.Rows)
{
if (DateTime.Parse(row.Cells[DueDateCellIndex].Text) < DateTime.Now)
{
row.BackColor = Color.Yellow;
}
}
lblAtLimit.Visible = (LoanGridView.Rows.Count > 3);
}
/// <summary>
/// Checks In Item
/// </summary>
/// <param name="sender">object sender</param>
/// <param name="e">event arguments</param>
protected void LoanGridView_RowCommand(object sender, GridViewCommandEventArgs e)
{
int isbnCellIndex = 0;
int copyCellIndex = 1;
BusinessLayer biz = new BusinessLayer();
try
{
int cmdRowIndex = Convert.ToInt32(e.CommandArgument);
int isbn =
Convert.ToInt32(LoanGridView.Rows[cmdRowIndex].Cells[isbnCellIndex].Text);
short copy =
Convert.ToInt16(LoanGridView.Rows[cmdRowIndex].Cells[copyCellIndex].Text);
biz.CheckIn(isbn, copy);
LoanGridView.DataBind();
lblCheckInStatus.OKText(String.Format("ISBN: {0} Copy: {1} successfully
checked in", isbn, copy));
}
catch
{
lblCheckInStatus.AlertText("Check-in failed");
}
}
}
31
32. MICHAEL CUMMINGS
Seattle, WA 98103
(406) 546-0952
michael.cummings@setfocus.com
SUMMARY
Highly motivated C# Software Developer/Programmer with experience using object oriented design
techniques and programming languages, including Microsoft .NET Technologies. Designed, developed and
documented multi-tier applications with Web and database integration. Demonstrated leadership abilities
and team work skills as well as ability to accomplish tasks under minimal direction and supervision.
http://www.linkedin.com/in/mikewcummings
TECHNICAL SKILLS
Programming Languages:
C#, XML, HTML, CSS, JavaScript, T-SQL
.NET Skill Set:
.NET Framework 3.5 and Common Type System, ASP.NET, SilverLight, AJAX, XAML, WPF, WCF, ADO.NET,
LINQ, .NET Class Libraries, Web Services
Databases:
MS SQL Server 2008
Software:
Visual Studio 2008
SetFocus, LLC Seattle, WA 8/09 - 10/09
.NET Masters Program
• Developed solutions for diverse programming scenarios in C#, employing object–oriented
programming concepts such as: encapsulation, inheritance, polymorphism, and abstraction.
• Used C#, LINQ and ADO.NET to define and implement secure middle-tier components using both
connected and disconnected environment strategies. Components were consumed by web
applications and windows applications utilizing SQL Server and stored procedures to perform logical
business transactions.
• Created and deployed XML Web Services using ASP.NET and Windows Communication Foundation
(WCF). Consumed Web Services from both Windows forms and ASP.NET web applications.
• Created complex business components in C# using .NET Class Library assemblies while migrating
and implementing them in a multi-tier environment suitable for .NET Remoting, XML Web Services
and WCF Services to address application infrastructure issues associated with building scalable
enterprise level applications used by many clients.
• Developed a Windows n-tiered “Public Library Management System” application and then ported
the application to a dynamic ASP.NET Internet/Intranet model utilizing the same secure middle tier
data access components. Non-public web pages were secured using Windows integrated and
ASP.NET forms security models.
• Created Deployment projects for .NET applications using Microsoft’s MSI packages.
32
33. PROFESSIONAL EXPERIENCE
Seattle, WA 9/08 – 7/09
IT Advisory Associate
• Assessed risk of internal IT controls over financial reporting. Conducted audits of access controls,
change management, program development, and computer
operations.http://msdn.microsoft.com/en-us/library/ms178472.aspx
• Managed heavy work loads in high stress situations under ambiguous direction. Demonstrated
adaptability in frequently changing situations and relationships.
• Interacted frequently with managerial and executive level personnel at wide variety of clients.
Bothell, WA 6/08 – 8/08
Enterprise IT Intern
• Performed monitoring and troubleshooting of network devices. Modeled network topologies.
Documented business processes & developed KPI's. Maintained internal SharePoint site.
• Demonstrated ability to learn new skills and apply diagnostic problem solving techniques.
Tacoma, WA 6/07 – 9/07
E-Commerce Intern
• Developed websites utilizing xhtml, css, javascript. Managed content for intranet and extranet.
Maintained internal SharePoint site.
• Built content base for new intranet release which involved achieving buy-in from business
stakeholders and influencing others without authority.
EDUCATION
Seattle University Seattle, WA 6/08
Bachelor of Arts, Business Administration - Overall GPA 3.92
• Major E-Commerce / Information Systems, Minor Philosophy
• University Honors Program
33
