mcintyre321

namespace _10PrintHello.Apps.Things.SirenTables
{
    public class Comment
    {
        public int postId { get; set; }

        [Sortable]
        public int id { get; set; }

        [Sortable]

mcintyre321

• use nsdepcop instead of project dependencies for layering so you can keep things in the same project
• generic action result in controllers instead of base type
• explicitly register your controllers rather than letting Controller Activator use them
• ditch your IOC container entirely
• use ValueOf for ids instead of ints
• hard code all non-secret config values each environment in your source code (using code, not json) and choose the right one based off a single 'env' variable
• use OneOf instead of custom Result objects/ Exceptions for control flow
• partition by feature vertical, not layer
• use delegates for your ports/adapters
• isolate your domain and use composition root

mcintyre321

using System;
using JSIL;
using JSIL.Meta;
using System.Collections.Generic;
using System.Linq;

public static class Program {
  
  public static void Main () {
    Dictionary<string, string[]> data = new Dictionary<string, string[]>(){

mcintyre321

.request{
  background-color: aliceblue;  
}

.response.status200{
  background-color: f5fff0
}

mcintyre321

void Main()
{
	var events = new ObservableCollection<Event>();

	var state = new NotifyCollection<object>();

	events.OnAdd(next =>
	{
		if (next is UserWasAdded)
		{

mcintyre321

 public class MyCustomRazorHostFactory : WebRazorHostFactory
    {
        public override System.Web.WebPages.Razor.WebPageRazorHost CreateHost(string virtualPath, string physicalPath)
        {
            // Implementation stolen from MvcRazorHostFactory :)
            var host = base.CreateHost(virtualPath, physicalPath);

            if (!host.IsSpecialPage)
            {
                return new MyCustomRazorHost(virtualPath, physicalPath);

mcintyre321

 [ComplexType]
    public class JsonProperty<T> where T : class
    {
        [Required]
        public string Json { get; private set; }
        
        protected JsonProperty()
        {
            this.SerializerSettings = new PolymorphicJsonSerializerSettings();
        }

mcintyre321

(function() {
  var __hasProp = {}.hasOwnProperty;

  (function(factory) {
    if (typeof require === 'function' && typeof exports === 'object' && typeof module === 'object') {
      return factory(require('knockout'), exports);
    } else if (typeof define === 'function' && define['amd']) {
      return define(['knockout', 'exports'], factory);
    } else {
      return factory(ko, ko.konva = {});

mcintyre321

var observify = function (obs, top) {
if (!top && !ko.isObservable(obs)) {
    return;
}
var object = ko.unwrap(obs);
if (Object.prototype.toString.call(object) === "[object Array]") {
    for (var i = 0; i < object.length; i++) {
        var v = object[i];
        if (!ko.isObservable(v)) {
            if (Object.prototype.toString.call(v) === "[object Array]") {

mcintyre321

Test scopes

• Unit test - an isolated test around a single 'unit' of code, although that can be anything from a method to a class to a series of (related) classes.
• Component test - same as a unit test
• Isolated test - a test that doesn't do any I/O, i.e. the Ports have been filled with in-memory Adapters
• Integration test - a test that interacts with deployed instances of the code and related services, possiby with some Test Doubles (mocked/faked/stubbed etc).
• End to End test - a test that entirely interacts with deployed instances using public interfaces
• Test-per-class - a convention that there should be one unit test for each class

Uses of tests