Rhyous http://www.rhyous.com Knight of the Code Fri, 31 Mar 2017 23:35:21 +0000 en-US hourly 1 19689186 Back up and restore a single table with foreign keys using SQL Server http://www.rhyous.com/2017/03/14/back-up-and-restore-a-single-table-with-foreign-keys-using-sql-server/ http://www.rhyous.com/2017/03/14/back-up-and-restore-a-single-table-with-foreign-keys-using-sql-server/#comments Tue, 14 Mar 2017 17:58:09 +0000 http://www.rhyous.com/?p=39411 Today I needed to backup a single database table, then test a change to the data, then if the change failed, restore the original data.

Below is how I did this.

What I used

I used SQL Server Management Studio to do all of the following steps.
I performed the steps on a database running on a SQL 2012 database server.

Part 1 – Backup the table

INTO MyTable_Bak
FROM MyTable;

Note: This will work usually, however, it won’t work if you have a calculated column. If you have a calculated column, create the table first, then specify the columns you are inserting. I didn’t have a calculated column, so I didn’t take time to figure this out.

Part 2 – Restoring the table

Step 1 – Finding the Foreign Key Constraints

SELECT Name, Object_Name(parent_object_id) as [Table]
FROM sys.foreign_keys
WHERE referenced_object_id = object_id('MyTable')

The results were like this:

Name                    Table
FKDDED6AECAD1D93C0      MyOtherTable1
FK166B6670AD1D93C0      MyOtherTable2

Step 2 – Get the Drop and Create for each Foreign Key

In SQL Management Studio Express, I went to each table in the above list, and did the following:

  1. Locate the foreign key under Database | MyDb | Tables | dbo.MyTable | Keys.
  2. Right-click on the Foreign Key and choose Script Key as | Drop and Create to | Clipboard.
  3. Paste this into the query window.
  4. Delete the USING MyDb statement and separate the DROP statement from the two ALTER TABLE statements.
  5. Repeat for the next foreign key constraint, grouping the DROP statements and the ALTER TABLE statements together.

Step 3 – Run the DROP statements

Run the two DROP statements created above.

ALTER TABLE [dbo].[MyOtherTable2] DROP CONSTRAINT [FK166B6670AD1D93C0]

Step 4 – Restore the table

I used this query to restore the table from the backup.

INSERT INTO MyTable (Id, Col1, Col2, Col3) -- Specify all columns here
SELECT (Id, Col1, Col2, Col3)              -- Specify all columns again here
FROM MyTable_Bak

Step 5 – Restore the foriegn key constraints

Run the ALTER TABLE scripts you grouped together from Step 2.

REFERENCES [dbo].[MyTable] ([Id])


REFERENCES [dbo].[MyTable] ([Id])

ALTER TABLE [dbo].[MyOtherTable2] CHECK CONSTRAINT [FK166B6670AD1D93C0]


Your table is restored.


  1. This is a simple process for a table with only a few foriegn key constraints but could be difficult if you have dozens of foreign key constraints.
  2. Also, this process might not work perfectly with calculated columns without changes to the above process.
  3. It should be easier to do this.

If you know of a better way that doesn’t require $oftware, let me know.

http://www.rhyous.com/2017/03/14/back-up-and-restore-a-single-table-with-foreign-keys-using-sql-server/feed/ 1 39411
Cleaning a customer folder in Visual Studio project http://www.rhyous.com/2016/11/29/cleaning-a-customer-folder-in-visual-studio-project/ http://www.rhyous.com/2016/11/29/cleaning-a-customer-folder-in-visual-studio-project/#comments Wed, 30 Nov 2016 00:19:43 +0000 http://www.rhyous.com/?p=39345 I have a Plugins directory in a Visual Studio project. I would like to delete all files from it when I clean.

Here is how I did this:

  1. Edit the .csproj file.
  2. Add the following to the very bottom of the .csproj file, just above the terminating </Project> tag.
      <Target Name="afterClean">
            <FilesToDelete Include="Plugins\**\*"/>
        <Delete Files="@(FilesToDelete)" />
  3. Save the .csproj file.

That should do it.

Update 12/14/2016:
You should be aware that when doing a custom clean, that in Visual Studio choosing Clean and then Build in two steps is not the same as doing Rebuild.

Clean <-- Cleans all projects Build <-- Builds all projects Rebuild <-- For each project, clean the project, then rebuild the project. So Rebuild is a huge problem and here is why: Since my code is pretty decoupled, my plugins don't reference the project hosting the plugins. So there is not dependency to guarantee the plugin-hosting project cleans and builds first. So when running reubild, a plugin might clean and build and then copy its files to the plugin directory. This could happen before the plugin-hosting project cleans and builds. So you can imagine that once the plugin-hosting project cleans and builds, the newly copied plugin files are cleaned. To fix this, I had to manually add a dependency or just not use Rebuild.

http://www.rhyous.com/2016/11/29/cleaning-a-customer-folder-in-visual-studio-project/feed/ 1 39345
Constructor Injection Hell http://www.rhyous.com/2016/09/27/constructor-injection-hell/ http://www.rhyous.com/2016/09/27/constructor-injection-hell/#comments Tue, 27 Sep 2016 22:17:50 +0000 http://www.rhyous.com/?p=39291 So I am a fan of dependency injection (DI), inversion of control (IoC), and the way DI and IoC allow for simplistic methods and Unit Tests. With DI, you can do method injection, property injection, or constructor injection. I don’t care which one a project uses, as long as they keep it simple.

Constructor Injection

This article is focussing on constructor injection. Constructor injection seems to be very popular, if not the most popular method of DI. Constructor Injection is considered to have a benefit because it requires the instantiator to provide all the dependencies an object needs in order to create an instance of it.

An Example of Constructor Injection Hell

Recently, I started working with NopCommerce, which uses DI heavily. They use Autofac and register objects with Autofac so it can provide concrete instances of any interfaces.

I am going to use NopCommerce as an example of what not to do. Now before I do this, I want to explain that NopCommerce overall has a very good architecture. Better than most. Finding something that I consider a “what not to do” in a project should not steer you away from NopCommerce. In fact, their plugin model and architecture works quite well.

Below is an example of constructor injection gone wrong from the OrderProcessingService.cs file in NopCommerce.

#region Ctor

        /// <summary>
        /// Ctor
        /// </summary>
        /// <param name="orderService">Order service</param>
        /// <param name="webHelper">Web helper</param>
        /// <param name="localizationService">Localization service</param>
        /// <param name="languageService">Language service</param>
        /// <param name="productService">Product service</param>
        /// <param name="paymentService">Payment service</param>
        /// <param name="logger">Logger</param>
        /// <param name="orderTotalCalculationService">Order total calculationservice</param>
        /// <param name="priceCalculationService">Price calculation service</param>
        /// <param name="priceFormatter">Price formatter</param>
        /// <param name="productAttributeParser">Product attribute parser</param>
        /// <param name="productAttributeFormatter">Product attribute formatter</param>
        /// <param name="giftCardService">Gift card service</param>
        /// <param name="shoppingCartService">Shopping cart service</param>
        /// <param name="checkoutAttributeFormatter">Checkout attribute service</param>
        /// <param name="shippingService">Shipping service</param>
        /// <param name="shipmentService">Shipment service</param>
        /// <param name="taxService">Tax service</param>
        /// <param name="customerService">Customer service</param>
        /// <param name="discountService">Discount service</param>
        /// <param name="encryptionService">Encryption service</param>
        /// <param name="workContext">Work context</param>
        /// <param name="workflowMessageService">Workflow message service</param>
        /// <param name="vendorService">Vendor service</param>
        /// <param name="customerActivityService">Customer activity service</param>
        /// <param name="currencyService">Currency service</param>
        /// <param name="affiliateService">Affiliate service</param>
        /// <param name="eventPublisher">Event published</param>
        /// <param name="pdfService">PDF service</param>
        /// <param name="rewardPointService">Reward point service</param>
        /// <param name="genericAttributeService">Generic attribute service</param>
        /// <param name="paymentSettings">Payment settings</param>
        /// <param name="shippingSettings">Shipping settings</param>
        /// <param name="rewardPointsSettings">Reward points settings</param>
        /// <param name="orderSettings">Order settings</param>
        /// <param name="taxSettings">Tax settings</param>
        /// <param name="localizationSettings">Localization settings</param>
        /// <param name="currencySettings">Currency settings</param>
        public OrderProcessingService(IOrderService orderService,
            IWebHelper webHelper,
            ILocalizationService localizationService,
            ILanguageService languageService,
            IProductService productService,
            IPaymentService paymentService,
            ILogger logger,
            IOrderTotalCalculationService orderTotalCalculationService,
            IPriceCalculationService priceCalculationService,
            IPriceFormatter priceFormatter,
            IProductAttributeParser productAttributeParser,
            IProductAttributeFormatter productAttributeFormatter,
            IGiftCardService giftCardService,
            IShoppingCartService shoppingCartService,
            ICheckoutAttributeFormatter checkoutAttributeFormatter,
            IShippingService shippingService,
            IShipmentService shipmentService,
            ITaxService taxService,
            ICustomerService customerService,
            IDiscountService discountService,
            IEncryptionService encryptionService,
            IWorkContext workContext,
            IWorkflowMessageService workflowMessageService,
            IVendorService vendorService,
            ICustomerActivityService customerActivityService,
            ICurrencyService currencyService,
            IAffiliateService affiliateService,
            IEventPublisher eventPublisher,
            IPdfService pdfService,
            IRewardPointService rewardPointService,
            IGenericAttributeService genericAttributeService,
            ICompanyService companyService,
            ShippingSettings shippingSettings,
            PaymentSettings paymentSettings,
            RewardPointsSettings rewardPointsSettings,
            OrderSettings orderSettings,
            TaxSettings taxSettings,
            LocalizationSettings localizationSettings,
            CurrencySettings currencySettings)
            this._orderService = orderService;
            this._webHelper = webHelper;
            this._localizationService = localizationService;
            this._languageService = languageService;
            this._productService = productService;
            this._paymentService = paymentService;
            this._logger = logger;
            this._orderTotalCalculationService = orderTotalCalculationService;
            this._priceCalculationService = priceCalculationService;
            this._priceFormatter = priceFormatter;
            this._productAttributeParser = productAttributeParser;
            this._productAttributeFormatter = productAttributeFormatter;
            this._giftCardService = giftCardService;
            this._shoppingCartService = shoppingCartService;
            this._checkoutAttributeFormatter = checkoutAttributeFormatter;
            this._workContext = workContext;
            this._workflowMessageService = workflowMessageService;
            this._vendorService = vendorService;
            this._shippingService = shippingService;
            this._shipmentService = shipmentService;
            this._taxService = taxService;
            this._customerService = customerService;
            this._discountService = discountService;
            this._encryptionService = encryptionService;
            this._customerActivityService = customerActivityService;
            this._currencyService = currencyService;
            this._affiliateService = affiliateService;
            this._eventPublisher = eventPublisher;
            this._pdfService = pdfService;
            this._rewardPointService = rewardPointService;
            this._genericAttributeService = genericAttributeService;
            this._companyService = companyService;

            this._paymentSettings = paymentSettings;
            this._shippingSettings = shippingSettings;
            this._rewardPointsSettings = rewardPointsSettings;
            this._orderSettings = orderSettings;
            this._taxSettings = taxSettings;
            this._localizationSettings = localizationSettings;
            this._currencySettings = currencySettings;


Problems in the Constructor Injection Implementation

So what is wrong with the above constructor? Well, a lot. Look, this is just bad code. While constructor injection is a good idea, taking it to this extreme is not a good idea. In fact, it is a terrible idea.

  1. The Constructor has too many parameters. While there is no limit, there is a best practice. See this stack overflow post: How many parameters are too many?
  2. The Constructor breaks the 10/100 rule. The constructor, with comments, method parameters, and method body is 126 lines of code. The method itself is far more than 10 lines of code, it is 39 lines of parameters and 39 more lines of member assignments, and is 80 lines of code.
  3. The Constructor breaks the keep it super simple (KISS) principle. Having to new up 39 concrete instances of the parameters in order to create an object is not simple. Imagine mocking 39 interface parameters in a Unit Test. Ugh!
  4. This constructor is a hint that the entire class is doing too much. The class is 3099 lines and clearly breaks the single responsibility principle. It is not the OrderProcessingService’s responsibility to store 39 dependent services.
  5. The constructor breaks the Don’t Repeat Yourself (DRY) principle. Almost all other classes in NopCommerce use constructor injection to access services.

Options for Refactoring

Option 1 – Container object

You could create a container that has all of these dependecies, a dependency model object for the OrderProcessingService. This object would house the 39 dependent services and settings. But Option 2 would be better.

Option 2 – Accessor objects

Looking at this from the Single Responsibility Principle, shouldn’t there be one class and interface, a ServiceAccessor : IServiceAccessor that allows one to access any dependent service? Instead of passing in 30 services, wouldn’t it make more sense to pass in a single object called a ServiceAccessor that implements IServiceAccessor? Should there be a ServiceAccessor of some sort? Turns out there is a static: EngineContext.Current.Resolve(). Since it is a static, maybe you could wrap it in a ServiceAccessor : IServiceAccessor object.

There are also a lot of “settings” objects passed into the constructor? Shouldn’t there be a SettingsService? Well, there is. One can pass in the ISettingsService and then call _settingService.LoadSetting().

Instead of passing in 39 parameters, methods with a single responsibility to fetch a service should be used.

Option 3 – Refactor the class

Since the class is 3099 lines. If the class were broken into logical pieces, naturally, the constructor for each smaller piece would have less parameters.

http://www.rhyous.com/2016/09/27/constructor-injection-hell/feed/ 2 39291
How to convert a string to an enum in C#? http://www.rhyous.com/2016/08/23/how-to-convert-a-string-to-an-enum-in-csharp/ http://www.rhyous.com/2016/08/23/how-to-convert-a-string-to-an-enum-in-csharp/#respond Tue, 23 Aug 2016 21:17:12 +0000 http://www.rhyous.com/?p=39273 Use this extension method:

using System;

namespace Rhyous.Extensions
    public static class StringExtensions
        public static T AsEnum<T>(this string str, T defaultValue)
            try { return (T)Enum.Parse(typeof(T), str, true); }
            catch { return defaultValue; }

So imagine you have this enum:

public enum LogLevel

Call it like this:

var levelStr = "Error";
LogLevel level = levelStr.AsEnum(LogLevel.Info);
http://www.rhyous.com/2016/08/23/how-to-convert-a-string-to-an-enum-in-csharp/feed/ 0 39273
Unit testing calls to complex extension methods http://www.rhyous.com/2016/08/11/unit-testing-calls-to-complex-extension-methods/ http://www.rhyous.com/2016/08/11/unit-testing-calls-to-complex-extension-methods/#respond Thu, 11 Aug 2016 23:12:41 +0000 http://www.rhyous.com/?p=39255 This article isn’t about unit testing an extension method. That is pretty straight forward. This article is about unit testing and object that calls an extension method where the extension method is difficult to test. Likely the method is difficult to test because it touches an external system, such as a database or a remote web service.

If you have an extension method that is simple and doesn’t touch and external system, it is easy to unit test. Look at the example below. There is nothing blocking you from Unit Testing code that calls this method.

public static int Add(this int left, int right) 
    return left + right;

Now image the extension method is more complex, say for a shopping cart.

public static void PlaceOrder(this Order order) 

How are you going to unit test code that calls an extension method that place an order and charges a customer’s Credit Card. Yikes. That is little harder to Unit Test, right?

How to Unit Test a call to an complex extension method

Imagine you have the following code:

  1. An object you are test called ObjectUnderTest
    public class ObjectUnderTest
        private void MyObject = new MyObject();
        public object SomeFunction() 
            return myObj.DoWork(val);
  2. An dependent object MyObject : IMyObject
    public class MyObject : IMyObject
     // ... some code
  3. An extension method on IMyObject: DoWork(this IMyObject obj, string value).
    public static object DoWork(this IMyObject obj, string value)
        // really complex stuff and touches external systems

You need Unit Tests for SomeFunction(). Imagine that all other code is 100% unit tested. But you are struggling with how to Unit Test SomeFunction because it has two dependencies:

  1. MyObject
  2. DoWork

The Unit Tests should not call the real DoWork because it does really complex stuff and touches external systems. However, you need the parent method to provide a valid return value.

Well, you could just drop the ExcludeFromCodeCoverageAttribute on the method and move on. But what if there are a half-dozen other objects that call the parent method that also need to be tested and they need a return value from SomeFunction()? It would be best to solve this in this object as so you only change one class file, not a half-dozen.

One option to resolve this is to use dependency injection. Dependency Injection (DI) simply means that any dependencies can be injected. When some people hear DI, they think they immediately need the huge overhead of an IoC Container. IoC containers are nice and have their uses. But using an IoC container only to allow unit tests substitute a dependency is a huge overkill. If your project already has an IoC container, feel free to use it. Otherwise, I recommend you use a simpler option. I prefer an internal lazy injectable property.

Creating a Lazy Injectable Property

An internal lazy injectable property is a property that is instantiated on first use if it is null, but always for code with internal access to swap out the property value. Here is the syntax:

Note: This assumes your unit tests references your project already, has InternalsVisibleTo configured, and has Moq from NuGet applied to the test project.

    internal IMyObject MyObjectProperty
        get { return _MyObject ?? (_MyObject = new MyObject()); }
        set { _MyObject= value; }
    } private List<object> _MyObject;

Look how simple the above code is. If _MyObject is null, the first time MyObjectProperty is called, it is instantiated to a new MyObject().It is internal because only the unit test will every replace it. I don’t really want this property exposed elsewhere. We can use InternalsVisibleTo to allow the Unit Tests access.Now my ObjectUnderTest will look like this:

public class ObjectUnderTest
    internal IMyObject MyObjectProperty
        get { return _MyObject ?? (_MyObject = new MyObject()); }
        set { _MyObject= value; }
    } private IMyObject _MyObject;

    public object SomeFunction()
        var val = "doesn't matter for this example";
        return MyObjectProperty.DoWork(val);

Now, in the unit test, the MyObjectProperty can be replaced with a mock IMyObject.

public void SomeFunctionTest()
{    // Arrange
    var mockMyObject = new Mock<IMyObject>();
    var objUnderTest = new ObjectUnderTest();
    objectUnderTest.MyObjectProperty = mockMyObject.Object;

    // More to come . . .

However, it is questionable whether this is even necessary. Does MyObject do anything that requires this level of abstraction? Not in this example. It isn’t the object itself that is complex, it is the extension method that really needs to be injectable.

Creating a Lazy Injectable Property for a method

You might be asking yourself, “What about the extension method? It is a method not an object. How can I inject that?” Well, you can. Remember, even methods can be treated as objects. The answer doesn’t change much. The only difference is understanding how to treat a method as an object.You can objectify methods using multiple objects such as Action, Func, Predicate, delegate, etc. I am not going to go into how to do that here beyond the minimal needed to accomplish this task.

Quick tip: Use Action for void methods, Predicate for methods return bool, Func for methods with any return value, delegate if you have ref or out paramters.

Here are the steps:

  1. Create the following Lazy Injectable Property inside ObjectUnderTest:

    Note: I am using Func because it has a return value of object. (See the Quick Tip a few lines up.) Since I have two paramters and a return type, I will specifically use the generic Func.

        internal Func<IMyObject, string, object> DoWorkMethod
            get { return _DoWorkMethod ?? (_DoWorkMethod = (obj, val) => { return obj.DoWork(val); }); }
            set { _DoWorkMethod = value; }
        } private Func<IMyObject, string, object> _DoWorkMethod;
  2. Change SomeFunction() to run the method via the Action object instead of running the method directly.
        public object SomeFunction()
            var val = "doesn't matter for this example";
            return DoWorkMethod.Invoke(MyObjectProperty, val);
  3. In your Unit Test, you can create your ObjectUnderTest. Then you can swap out the DoWork method object.
    public void SomeFunctionTest()
        // Arrange
        var mockMyObject = new Mock<IMyObject>();
        var objUnderTest = new ObjectUnderTest();
        objUnderTest.MyObjectProperty = mockMyObject.Object;
        bool methodWasCalled = false;
        objUnderTest.DoWorkMethod = (obj, val) => {
            methodWasCalled = true;
            return new object();
        // Act
        var result = objUnderTest.SomeFunction();
        // Assert

You are now 100% covered. The only code we can’t cover is the lambda call to obj.DoWork because we can’t Unit Test that as it touches an external system. Which is why we marked it with the ExcludeFromCodeCoverageAttribute.

http://www.rhyous.com/2016/08/11/unit-testing-calls-to-complex-extension-methods/feed/ 0 39255
A SerializableDictionary in C# http://www.rhyous.com/2016/06/14/a-serializabledictionary-in-csharp/ http://www.rhyous.com/2016/06/14/a-serializabledictionary-in-csharp/#comments Tue, 14 Jun 2016 21:59:07 +0000 http://www.rhyous.com/?p=39187 If you create a static Dictionary in code, every time you need to change the dictionary, you have change code, recompile, and redeploy. Wouldn’t it be nice if you didn’t have to change code. What if you could create your dictionary in an Xml file and deserialize it. You can now make the change outside of code.

using System.Collections.Generic;
using System.Xml.Serialization;

namespace Rhyous.EasyXml
    public class SerializableDictionary<TKey, TValue>
        : Dictionary<TKey, TValue>, IXmlSerializable
        public string KeyName = "key";
        public string ValueName = "value";

        #region constructors
        public SerializableDictionary()

        public SerializableDictionary(IEqualityComparer<TKey> comparer)
            : base(comparer)

        #region IXmlSerializable Members
        public System.Xml.Schema.XmlSchema GetSchema()
            return null;

        public void ReadXml(System.Xml.XmlReader reader)
            var keySerializer = new XmlSerializer(typeof(TKey), null, null, new XmlRootAttribute(KeyName), null);
            var valueSerializer = new XmlSerializer(typeof(TValue), null, null, new XmlRootAttribute(ValueName), null);

            var wasEmpty = reader.IsEmptyElement;

            if (wasEmpty)

            while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
                var key = (TKey)keySerializer.Deserialize(reader);
                var value = (TValue)valueSerializer.Deserialize(reader);
                Add(key, value);

        public void WriteXml(System.Xml.XmlWriter writer)
            var keySerializer = new XmlSerializer(typeof(TKey));
            var valueSerializer = new XmlSerializer(typeof(TValue));

            foreach (TKey key in Keys)
                keySerializer.Serialize(writer, key);
                valueSerializer.Serialize(writer, this[key]);
http://www.rhyous.com/2016/06/14/a-serializabledictionary-in-csharp/feed/ 1 39187
Code faster and with higher quality using code generation http://www.rhyous.com/2016/06/07/code-faster-and-with-higher-quality-using-code-generation/ http://www.rhyous.com/2016/06/07/code-faster-and-with-higher-quality-using-code-generation/#respond Tue, 07 Jun 2016 18:30:58 +0000 http://www.rhyous.com/?p=39167 Code generation is the idea of having a tool write code written for you. If you use a modern IDE, such Visual Studio, you likely use a type of code generation, even if you think you don’t.

Anytime code is written for you, it is code generation. You use code generation whenever you do the following:

  1. Create a new solution or project – Each project is a template with a base set of code ready for you to use.
  2. Add a new class, interface, or another item to a project – When adding a new class to a project, the class comes with a pre-created class object. If you add a new class called Person, the following class file would be created and added to the project:
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    namespace LANDesk.Licensing.WebServices.File.Tests
        class Person

    The using statements are lines of code. The namespace and class definitions and the brackets are lines of code.  You get 11 lines of code not including the whitespace lines. This code was created for you because you didn’t have to write it. That doesn’t mean it is 100% useful. If you don’t use threading, the last using statement can be removed.

    Similarly, other items that are added have a base set of code.

  3. Use code snippets – Code Snippets are quite powerful. With a few characters and then the tab key twice, you can create a lot of code. There are many built-in code snippets. If you are using them, you should be.
  4. Other Visual Studio features – Visual Studio has some specific use cases where it provides code generation. For example, if you highlight a class name and choose Extract Interface, Visual Studio will generate and interface from the
  5. Plugins and 3rd party tools – Many plugins can generate code for you. For example, Resharper can do numerous code generation features, such as properly overriding the Equals method. ORMs, such as Entity Framework, have code generation tools. Entity Framework can generate most the Entities (class files that represent objects stored in database tables)  for you.

You can enhance the code generation tools

Most of these features are available as platforms for you to build upon. Enhancing these can be a simple as copying an existing item or as complex as developing your own product.

In Visual Studio, you can do any of the following: (listed in order of ease of use)

  1. Create your own snippets.
  2. Create your own class/item templates
  3. Download or purchase additional code generation plugins
  4. Create your own Project/Solution templates
  5. Create your own Visual Studio plugins/3rd party tools

If you are repeatedly writing the same code over an over again, you probably would benefit from creating a code generation solution.

Faster and higher Quality

When a human writes something, there is room for human error. If a person writes the same thing over and over, there is a tendency to minimize and cut corners. Also, there are many standard pieces of code that have already gone through significant use and bug fixes resulting in a stable and scalable piece of code. For example, overriding Equals in a class isn’t always straight forward. If you do it yourself, you might be left wondering if you have properly overridden Equals of if your implementation has well-known bugs? Do you leave those bugs in or research and fix them? If you research and fix them, how long will it take you each time you override Equals to make sure you accounted for all well-known bugs? However, if you use a generator with a standard, tested, and bug-free piece of code, your code will be higher quality and it will be created almost instantly. See, faster and higher quality.

I am hoping to have time to create a series of posts on this topic, starting with Snippets. But to get you started, check out my Visual Studio snippets for C# on GitHub.



http://www.rhyous.com/2016/06/07/code-faster-and-with-higher-quality-using-code-generation/feed/ 0 39167
Using a method for the sole purpose of documentation http://www.rhyous.com/2016/05/03/using-a-method-for-the-sole-purpose-of-documentation/ http://www.rhyous.com/2016/05/03/using-a-method-for-the-sole-purpose-of-documentation/#respond Tue, 03 May 2016 21:54:49 +0000 http://www.rhyous.com/?p=39114 Some developers like to write one line of code for complex tasks. It’s called code golf and there is a whole subdomain on StackExchange dedicated to code golf. Also, I have seen an idea mentioned on some forums that you should never have a method that is a single line of code. I am going to challenge that statement and suggest that when a single line of code is difficult to understand, wrapping it in a method for the sole purpose of readability is a good practice to follow.

Below is an example of one line of code.

for (int i = 0; i < max; i++) { wsProducts[i].Features = dbContext.Products.Select(p=>p.Id == wsProducts.Id).Features.Select(f=>f.ToServiceObj()).ToList(); }

I am not going to argue whether one line of code is good or bad to have on one line. I like my for loops to be broken out like this.

for (int i = 0; i < max; i++) 
  wsProducts[i].Features = dbContext.Products.Select(p=>p.Id == wsProducts.Id).Features.Select(f=>f.ToServiceObj()).ToList();

But I am not going to dictate my personal preference onto other developers. That is not the point of this article. The point of this article is to talk about the benefit of a method for the sole purpose of documentation and making the code more readable. Besides, there are hundreds of other single lines of code that are difficult to understand. Thanks to Linq alone, C# now has plenty of examples. But this isn’t just a C# concept. This concept work in C++, Java, JavaScript, or any language. This concept is language agnostic.

So to start with, what is the above code doing? Can you tell from this line of code? I couldn’t at first glance. I had to examine it further. Who wrote this. (Hopefully, it wasn’t me two years ago. It probably was.)

Well, my ORM has Products and each product has a list of Features. My WebService also has Products and each Product has a list of Features. However, the ORM Product and Feature classes are not the same object types as the WebService Product and Feature classes. They are different objects in different namespaces. So basically, this code gets the list of features foreach product from the database and converts the features to a WebService Feature type, puts them in a list and assigns them to the WebService Product type’s feature list.

Wait, why did I have to explain that to you. Why didn’t you simply know what the code did? Because the code is not self-explanatory. Is is not easy to read or understand.

What if instead of our embedding our loop in our current code, we created and called this method instead?

GetFeaturesFromDatabase(MyDbContext dbContext, IEnumarable<MyWebService.Product> wsProducts) 
  for (int i = 0; i < max; i++) { wsProducts[i].Features = dbContext.Products.Select(p=>p.Id == wsProducts.Id).Features.Select(f=>f.ToServiceObj()).ToList(); }

Basically, we encapsulate (did I just use the term encapsulation outside of a CS 101 course) the complex code in a method and use the method instead.

GetFeaturesFromDatabase(dbContext, wsProducts);

Is that not clearer and easier to read?

But should we do this?

Let’s assume that our code already uses dependency injection and we already can mock the dbContext, and our code already has Unit Tests that are passing. So we don’t really need this method for any other reason other than documentation.

My answer is YES! Yes, using a method for the sole purpose making the code self-documenting and easier to read is worth it.

What do you think?

http://www.rhyous.com/2016/05/03/using-a-method-for-the-sole-purpose-of-documentation/feed/ 0 39114
SQL Query to Entity Framework Cheat Sheet http://www.rhyous.com/2016/04/18/sql-query-to-entity-framework-cheat-sheet/ http://www.rhyous.com/2016/04/18/sql-query-to-entity-framework-cheat-sheet/#respond Mon, 18 Apr 2016 23:55:44 +0000 http://www.rhyous.com/?p=38999 The following are examples of SQL queries and how to execute them with Entity Framework

SELECT * with Entity Framework

SELECT * FROM Contacts
var mydbContext.Contacts.ToList();

SELECT Id with Entity Framework

This is really for how to select any single column.

List<int> idList = dbContext.Contacts.Select( c => c.Id ).ToList(); // Assuming Id is of type int

SELECT only one row with Entity Framework

This is really for how to select any single row from a table.

SELECT * FROM Contacts where Id = 10
var id = 10;
var contact = dbContext.Contacts.SingleOrDefault( c => c.Id = id );

SELECT only one result with Entity Framework

This is really for how to select any single value from a single row in a table.

SELECT UserId FROM Contacts where Id = 10
var id = 10;
int userId = dbContext.Contacts.Where( c => c.Id = id ).Select( c => c.UserId ).SingleOrDefault();

SELECT first result with Entity Framework

This is really for how to select the first value from a list of returned rows from a table.

SELECT TOP 1 * FROM Contacts
var id = 10;
int userId = dbContext.Contacts.FirstOrDefault();

INSERT INTO with Entity Framework

INSERT INTO dbo.LD_User (Name, Type, Active, CreateDate, CreatedBy)
VALUES ('user1', 1, 1, GetDate(), 101)
var user = new User { Name = "user1", Type = UserType.Contact, true, DateTime.Now, User.System };

Note: UserType.Contact and User.System are enums in the above example.

INSERT INTO … SELECT with Entity Framework

Imagine you have these three tables. Product, ProductGroup, ProductGroupMembership. You want to make Products a member of a group by inserting into the ProductGroupMembership table.

INSERT INTO ProductGroupMembership (ProductId, GroupId, CreateDate, CreatedBy)
SELECT Id, @GroupId, GetDate(), @CreatedBy FROM Product
WHERE Id IN (1, 2, 3, 4, 5) -- there could be hundreds or thousands of numbers in the IN statement
EPIC FAIL!!! Can't be done without raw sql and opening up to sql injection attacks.

However, you can create a stored procedure that takes and user-defined table called ArrayOfInt. Then add EntityFrameworkExtras.EF6, which is available as a NuGet package, to call the storedprocedure and pass it an array.

WHERE with many AND/ORs with Entity Framework

Imagine you have these three tables. Product, ProductGroup, ProductGroupMembership. You want to make Products a member of a group by inserting into the ProductGroupMembership table.

You have a list of software Products provided to you. However, the input only includes Product.Name and Product.Version. You now need to check if the products exist and get the id.

WHERE (Name = 'Product 1' AND Version = '10.0')
WHERE (Name = 'Product 2' AND Version = '10.0')
WHERE (Name = 'Product 3' AND Version = '10.1')
WHERE (Name = 'Product 4' AND Version = '10.0')
WHERE (Name = 'Product 5' AND Version = '1.0')
EPIC FAIL!!! Can't be done without raw sql

However, you can add LinqKit’s PredicateBuilder to do this. PredicateBuilder works on top of Entity Framework and is available as a NuGet package. See how I used it here: Entity Framework and many WHERE clauses

http://www.rhyous.com/2016/04/18/sql-query-to-entity-framework-cheat-sheet/feed/ 0 38999
How to create a WordPress content filter plugin? http://www.rhyous.com/2016/04/15/how-to-create-a-wordpress-content-filter-plugin/ http://www.rhyous.com/2016/04/15/how-to-create-a-wordpress-content-filter-plugin/#respond Fri, 15 Apr 2016 13:19:03 +0000 http://www.rhyous.com/?p=39078 It is pretty easy to roll out a WordPress plugin that adds a content filter.

Creating a WordPress content filter plugin

Here are the basic steps to replace the content with a filter. This example is very rudimentary and replaces all of the content, which you would probably never really do.

  1. Create a new file called MyPlugin.php
  2. Add this code:
    Plugin Name: <Your Plugin Name>
    Version: 1.0
    Plugin URI: tba
    Author: <your name>
    Author URI: <your web site>
      function handleContentFilter( $content = null ) {
        return "Hello, World!";
      $test = add_filter( "the_content", "handleContentFilter" );
  3. Upload (or copy) MyPlugin.php to the /wp-content/plugins/ directory in your WordPress install.

Replace content based on a search string

This is more likely what you are going to do. Sames steps as above, but change the file as follows:

  function handleContentFilter( $content = null ) {
    return str_replace("FindMe","Hello, World!", $content);

Using a WordPress shortcode plugin

  1. Start a new Post
  2. type in the following:


  3. Click Preview.

Your post should have replaced FindMe with “Hello, Word!”.

A better WordPress content filter plugin template

While the above is all you need, a more scalable solution might involve using classes. Here is a template that uses classes.

Plugin Name: <Your Plugin Name>
Version: 1.0
Plugin URI: tba
Author: <your name>
Author URI: <your web site>

// A class to manage your plugin
class MyPlugin {
  public function MyPlugin( $shortCodeHandler ) {
    $result = add_filter( 'the_content', array( $shortCodeHandler, 'handleContentFilter' ) );
// A class to handle your shortcode
class ContentFilterHandler {
  public function handleContentFilter( $content = null ) {
    return str_replace("FindMe","Hello, World", $content);
$contentFilterHandler  = new ContentFilterHandler();
$plugin = new MyPlugin( $contentFilterHandler  );

http://www.rhyous.com/2016/04/15/how-to-create-a-wordpress-content-filter-plugin/feed/ 0 39078