.NET (5) Implementation of WPF using the Presentation Abstraction and Control Pattern

We just released the initial version of an architectural framework for Windows Presentation Framework (WPF) that makes use of the Presentation-Abstraction-Control (PAC) pattern. This framework is meant to be used for any .NET 5 projects that are building WPF applications.

The release contains type definitions for implementation generically, WPF-specific type definitions, and CodeFactory automation commands and helpers for building your final code artifacts.

Please see the following link for more details of the open-source project:

https://github.com/CodeFactoryLLC/PACWPF

Now available: Common Delivery Framework

The Common Delivery Framework (CDF) library provides foundational blocks of code for common application delivery needs. (.NET Standard and .NET Core / 5 and later)

Core purpose of the project:

The CDF includes a set of commonly used artifacts that all modern .NET applications can make use of. Currently the CDF focuses primarily on logging and exception handling. By providing a set of common building blocks for logging (leveraging the Microsoft.Logging namespaces) while still allowing the use of 3rd party frameworks like nLog or xUnit.

For Exception Handling the framework defines a large selection of Types:

  • Communication Exception

  • Configuration Exception

  • Data Exception

  • External Access Exception

  • Logic Exception

  • Security Exception

  • Timeout Exception

  • Unhandled Exception

  • Validation Exception

All of these different types are sub-classes of Managed Exception which wraps up and understands how to convert to the standards compliant Problem type that can safely be sent across service boundaries.

The final output is published as a Nuget Package.

Now available on GitHub (CodeFactory.Markup.Adapter)

This open-source project contains a collection of Interface definitions, base classes and pre-defined return types. Collectively this Adapter Pattern implementation is meant to facilitate the conversion one markup language to another using CodeFactory.

  • AdapterHost definition

  • BaseTagAdapter definition

  • Conversion Result Type definition

  • IAdapterHost interface definition

  • ITagAdapter interface definition

Conversion scenarios range from WebForms (*.aspx files) to Blazor (*.razor files), Silverlight (*.xaml files) to Unity, or YAML to TAML, amongst many many other variations.

The final output is published as a Nuget Package which makes available the adapter pattern interfaces and base classes to implementing authors.

Try the Markup Adapter today. (GitHub link)

Guidance updated for WebForms to Blazor migration automation.

We recently updated the #CodeFactory WebForms2Blazor automation templates and guidance/documentation over on GitHub. Check it out!

https://github.com/CodeFactoryLLC/WebForms2BlazorServer

This project is an implementation of a CodeFactory automation template designed specifically to migrate an existing legacy .NET Webforms application to a Blazor Server application. This template is offered as open-source and anyone can download and alter it to suit the particular needs of any WebForms migration efforts that they are faced with.

What organizations can benefit from CodeFactory?

Independent Software Vendors -- Often, small to mid-sized ISVs struggle to address accrued or acquired technical debt as technical stacks evolve at a very rapid pace, all while trying to keep up with the constant demands from current and new customers. These ISVs often have limited teams and can seldom find the time to clean up or update older systems used by their clients and get locked into supporting lots of versions of their products since it is hard to get consistently coded systems that upgrade easily. This user base would likely use CodeFactory multiple times on their products to extend their effective lifespan. They could also use CF to more quickly build new products for their customer base.

System Integrators/Consulting/Development shops -- CodeFactory can help by reducing the cost/complexity of delivery on new system builds or app modernization efforts. With automation tools available, the consulting firms can more competitively bid high end projects and/or simply convert the saved time into additional project buffer/margins. Since consultants have new customers all the time, the need to re-use CodeFactory over and over with new projects seems likely once they have acclimated to how it is used.

Internal Dev teams supporting complex or simple app portfolios. Since CodeFactory can be used on green-field projects scaffolding up the plumbing code quickly and to the desired architectural specs, reduces the time teams need to focus on anything beyond core solution logic. Onboarding new developers is simplified, as they don’t need to be trained on how the company wants certain things done, like bounds checking, error handling, etc. because that all gets managed by the factory. Whereas brown-field projects (uplifts/refactors) benefit from how quickly CodeFactory can search, transform and inject code throughout the solution in real-time. I would agree that app dev teams supporting small portfolios might use this once to uplift an app and then set it aside, but for organizations that have a portfolio of apps, the refactoring never really ends and combine that with need for new app creation, and the usefulness for CodeFactory extends greatly.

#HelpWanted from CodeFactory Community Builders

We've been building & publishing open-source reference projects to GitHub so the #CodeFactory user community can easily use, extend and/or contribute their own automation template ideas. We are encouraging community submitted open-source reference models/projects for a variety of scenarios. Here are a few....

  • Updating Telerik & Infragistics UI controls

  • Moving data layers to/from Oracle, SQL, mySQL

  • Migrating .NET Framework apps to .NET Core Standard

  • Creating JSON/WCF/WebService from Entity Model POCO

  • Refactoring older MVC apps to the latest version of MVC

Got more ideas? Want to participate in one of these projects? Definitely let us know.

Open Source contribution from LifeCycle Delivery - Common Delivery Framework

LifeCycle Delivery’s open source advocates recently announced that the CodeFactory "add member" command will now support a separate component called the #CommonDeliveryFramework. This small open source library focuses on providing standardized extensions to logging and exception management.

Nuget Package for exception handling and logging management

Nuget Package for auto-generating problems returns from controller calls

 GitHub Location: Common Delivery Framework

If you are not using these libraries it will not impact the asp.net core command library from CodeFactory.

Available now: CodeFactory SDK Quick Start Services

Professional installation

Since you might not have time for learning curves, our in-house experts will get your team up and running with CodeFactory in a flash.

Custom optimization

Get the right configurations and automation templates setup for your software development team from experts who are fully trained in Visual Studio and CodeFactory best practices

Hands-on training

Receive professional training, mentoring, and documentation on CodeFactory use and knowledge to prepare your delivery teams to tackle exciting new projects.

CodeFactory automation Proof of Concept - "How can I easily convert a legacy Web Form app to to .NET Core/Blazor?"

We recently recorded a basic demo of CodeFactory for a specific refactor scenario to a potential partner. It's centered on migrating an ASP.net web forms project to Blazor. In under an hour we walk through the conversion process. The actual app conversion is completed within the first 5 minutes, the next 30 minutes are focused on how CodeFactory and this specific automation template works, with the remaining 15-20 min being Q&A/conversation regarding other potential automation scenarios.  

We published this automation template as an open-source reference project on GitHub/NuGet so people can try it out and ultimately build their own automation templates with our open-source SDK. A paid (or trial) CodeFactory Run-time (RT) client is required in order to execute the pre-built automations. We plan to add more reference models for community use and feedback in the coming months. 

More information about the broader product vision and capabilities (beyond this specific scenario) along with our first pass at documentation can be reviewed at the product site: www.codefactory.software 

Mastodon