ProgramGood.Net favicon.ico 2012-05-20T14:32:15.759125-04:00 Dave Mateer The journey to becoming a great programmer http://www.programgood.net/ DasBlog Mastering C#–Properties http://www.programgood.net/PermaLink,guid,bd110f83-9804-4d7b-882e-1dc722ae449a.aspx 2012-05-20T14:04:01.2435-04:00 2012-05-20T14:32:15.759125-04:00
public class Greeter
{
//field
//generally speaking don't give other classes access to your fields
//can think of it as how it is storing state for the class
privatereadonlystring speaker;

//property.. this is public.. the behaviour
publicstring Speaker
{
get { return speaker; }
//we've got an immutable type.. something that can't be changed after it is constructed
//immutable is nice as don't need to worry about change of state
//set { speaker = value; }
}

public Greeter(string speaker)
{
//this is referring to current object
this.speaker = speaker;
}

//public methods are part of the API
publicstring SayHello(string recipient)
{
if (recipient == null)
{
thrownewArgumentNullException("recipient");
}
if (speaker == null)
{
return"Hello " + recipient;
}
return"Hello " + recipient + " from " + speaker;
}
}

private fields good.. readonly v.good as then we’re immutable therefore easier as don’t need to worry about changes in state

[Test]
publicvoid SpeakerProperty_IsSetFromConstructor()
{
Greeter greeter = newGreeter("Rob");
Assert.AreEqual("Rob", greeter.Speaker);
Assert.AreNotEqual("rob", greeter.Speaker);
}

asdf

public class Greeter
{
//field
//generally speaking don't give other classes access to your fields
//can think of it as how it is storing state for the class
//private string speaker;

//property.. this is public.. the behaviour
//public string Speaker
//{
// get { return speaker; }
// //we've got an immutable type.. something that can't be changed after it is constructed
// //immutable is nice as don't need to worry about change of state

// //value is a contextual keyword
// set { speaker = value; }
//}

//auto props introduced in C#3
//with private property is now immutable..however not quite as could change it in this class
//if want to protect against this, then make a backing field with readonly like above
publicstring Speaker { get; privateset; }

public Greeter(string speaker)
{
//this is referring to current object
this.Speaker = speaker;
}

asdf

public class Greeter
{
//field
//generally speaking don't give other classes access to your fields
//can think of it as how it is storing state for the class
//private string speaker;

//property.. this is public.. the behaviour
//public string Speaker
//{
// get { return speaker; }
// //we've got an immutable type.. something that can't be changed after it is constructed
// //immutable is nice as don't need to worry about change of state

// //value is a contextual keyword
// set { speaker = value; }
//}

//auto props introduced in C#3
//with private property is now immutable..however not quite as could change it in this class
//if want to protect against this, then make a backing field with readonly like above
publicstring Speaker { get; set; }
//private readonly string speaker;
//public string Speaker
//{
// get
// {
// Console.WriteLine("Returning speaker = " + speaker);
// return speaker;
// }
//}

public Greeter(string speaker)
{
this.Speaker = speaker;
}

//public methods are part of the API
publicstring SayHello(string recipient)
{
if (recipient == null)
{
thrownewArgumentNullException("recipient");
}
if (Speaker == null)
{
return"Hello " + recipient;
}
return"Hello " + recipient + " from " + Speaker;
}

auto properties.  Backing fields.

C# Jon Skeet–Methods Constructors and Exceptions http://www.programgood.net/PermaLink,guid,e1094a33-fd51-4c0b-897d-31a2789cf9ff.aspx 2012-05-20T13:32:16.540375-04:00 2012-05-20T13:32:33.352875-04:00

public class Greeter
{
//adding a parameter
publicstring SayHello(string recipient)
{
//return "Hello " + recipient;
returnstring.Concat("Hello ",recipient);
}
}

compiled changes the + to a string.Concat

[TestFixture]
publicclassGreeterTest
{
[Test]
publicvoid SayHello_ReturnsHelloWithReceipientName()
{
Greeter greeter = newGreeter();
//adding an argument
string greeting = greeter.SayHello("Jon");
Assert.AreEqual("Hello Jon", greeting);
}
}
//constructor is used to build an instance of a class, an object
//if no constructor the compiler will make one for us.
//which calls the base class constructor..
public Greeter() : base()
{
}

adding a constructor (ctor)

public class Greeter
{
//a private field..if it is only set within the constructor then set it readonly
//the = "asdf" is a variable initialiser
privatereadonlystring speaker = "Rob";

public Greeter(string speaker)
{
this.speaker = speaker;
}

publicstring SayHello(string recipient)
{
return"Hello " + recipient + " from " + speaker;
}
}

variable initialiser.. and readonly field

[TestFixture]
publicclassGreeterTest
{
[Test]
publicvoid SayHello_ReturnsHelloWithReceipientNameAndSpeakerName()
{
Greeter greeter = newGreeter("Rob");
string greeting = greeter.SayHello("Jon");
Assert.AreEqual("Hello Jon from Rob", greeting);
}

[Test]
publicvoid CanConstructingGreeterWithoutSpeakerName()
{
//null here... is a special kind of reference.. ie a blank piece of paper with directions to nowhere
//it is not an empty string
newGreeter(null);
}

[Test]
publicvoid SayHello_ReturnsHelloWithReceipientNameButNoSpeakerName()
{
Greeter greeter = newGreeter(null);
string greeting = greeter.SayHello("Jon");
Assert.AreEqual("Hello Jon", greeting);
}

[Test]
publicvoid SayHello_ThrowsExceptionWithNullReceipient()
{
Greeter greeter = newGreeter("Rob");
//Assert.Throws<ArgumentNullException>(() => greeter.SayHello(null));
Assert.Throws(typeof (ArgumentNullException), delegate
{
greeter.SayHello(null);
});
}

null references.

public class Greeter
{
//a private field..if it is only set within the constructor then set it readonly
//the = "asdf" is a variable initialiser
privatereadonlystring speaker;

public Greeter(string speaker)
{
this.speaker = speaker;
}

publicstring SayHello(string recipient)
{
if (recipient == null)
{
thrownewArgumentNullException("recipient");
}
if (speaker == null)
{
return"Hello " + recipient;
}
return"Hello " + recipient + " from " + speaker;
}
}

variable initialiser.  readonly fields – use where only set in the constructor

C#–Jon Skeet VS Environment and First Class http://www.programgood.net/PermaLink,guid,bbbf20de-d517-4619-adf3-e89b025da68c.aspx 2012-05-19T22:03:06.8534359-04:00 2012-05-20T12:48:39.7435-04:00

an assembly is a library or executable or website

System.Core   are the standard(ish) libraries..more general

Microsoft.CSharp  .. are something lke the mono team would create their own ones..? eg Win32 specific..but mono would probably have to do a Microsoft.CSharp..

image

Jon doesn’t like warnings.. there is a VS setting to make all warnings errors.

[TestFixture]
//PascalCase
publicclassGreeterTest
{
[Test]
publicvoid SayHello_ReturnsHello()
{
//declaring a variable of type Greeter.
//calling the constructor
//assign the value back from the constructor to greeter
//the value of the greeter variable is 'directions' to the Greeter... way of getting to the object
//eg directions to house of a bit of paper
//ie it is the reference type
Greeter greeter = newGreeter();
//this has the same reference.. there is only 1 instance of greeter
//the value isn't the object
Greeter theSameGreeter = greeter;
//camelCase
//Greeter greeterOther;

//all types begin with Capital
//string, int, unit, byte, object.. alias for full type name System.String ... int is to System.Int32
//not Random
//string (System.String) is a reference type
string greeting = greeter.SayHello();
//passing in arguments.. a string literal
Assert.AreEqual("Hello", greeting);
}
}

Jon describing in detail 3 lines of code.

//a class is a sort of blueprint of an object
//some information
//some associated behaviours
//eg a house...
//colour walls are, colour windows are...
//behaviour change colour, turn on heating
public class Greeter
{
//behaviour is usually in methods in c#
publicstring SayHello()
{
return"Hello";
}
}
TekPub C#4 Jon Skeet http://www.programgood.net/PermaLink,guid,616d76f6-b63e-4e7e-b95d-313a442b6665.aspx 2012-05-19T16:20:34.7909359-04:00 2012-05-19T16:20:34.7909359-04:00

Supposed to be the introduction episode Smile

Dynamic

static void Main(string[] args)
{
object x = newList<int>();
//will give an InvalidCastException at runtime
string y = (string) x;
Console.WriteLine(y.Length);
}
object x = "hello";
string y = (string) x;
Console.WriteLine(y.Length);

gives answer of 5

object x = null;
//we can cast a null reference
string y = (string)x;
//but we cant dereference it..get a nullReferenceException
Console.WriteLine(y.Length);

sdf

//don't think of x at any type... sort out at execution time
dynamic x = "hello";
//5
Console.WriteLine(x.Length);

//an array
x = newint[] {10, 20, 30 };
//3
Console.WriteLine(x.Length);

from

int x = 123;
int y = 10;
Console.WriteLine(x-y);

image

using ildasm to disassemble the debug assembly.  The nop statements are for debug.

This is op code (IL).. i4 is like int32

load 123 and put into stack position 0

load 10 and put into stack position 1

then put into dynamic types

Named Arguments

Whats an argument and whats a parameter?

static void Main(string[] args)
{
//provide an argument
Foo("hello");
}

//x is a parameter
staticvoid Foo(string x)
{
Console.WriteLine(x);
}
}

image

Got it the wrong way round.. hard to tell which is which in MessageBox.Show

static void Main(string[] args)
{
//named argument C#4
Foo(x: "hello", y:"Rob");
//referenced System.Windows.Forms
MessageBox.Show(caption:"title", text:"body");
}

//x is a parameter
staticvoid Foo(string x, string y)
{
Console.WriteLine(x + " " + y);
}

better!

Optional Parameters

static void Main(string[] args)
{
//named arguments
Foo(y: "Rob");
Foo(y: "Dave");
Foo(y: "Mike");
Foo(y: "Bill");
Foo("Hi", "Anders");
Foo();
}

//optional parameters
//if first parameter is optional all have to be
staticvoid Foo(string x = "Hello", string y = "Everone")
{
Console.WriteLine(x + " " + y);
}
}

Covariance and Contravariance

Some code here.. poster child of the more used covariance is IEnumerable<T>.. look for out keword.  And it is to do with hierarchies.

class Fruit { }
classBanana : Fruit { }
classApple : Fruit { }

//interface IEnumerable<out T>
//{
// IEnumerator<T> GetEnumerator();
//}

//interface IEnumerator<out T> : IDisposable
//{
// T Current { get; }
// bool MoveNext();
// void Reset();
//}

//covariance values coming out of an interface
//usually happens with IEnumerable of T
interfaceIFoo<out T>
{
T GiveMeAnInstanceOfT();
//void TakeanInstanceOfT(T instance);
}

//contravariance is in

classProgram
{
staticvoid Main(string[] args)
{
//List<Banana> bunchOfBananas = new List<Banana>();
IFoo<Banana> bunchOfBananas = null;

//cant convert from a list of banana to a list of fruit
//List<Fruit> fruitBowl = new List<Banana>();

//List<Fruit> fruitBowl = bunchOfBananas;
//fruitBowl.Add(new Apple());

//Banana banana = bunchOfBananas[0];

//IEnumerable - sequence..cant add.. can only observe
//IEnumerable<Fruit> fruitBowl = bunchOfBananas;
IFoo<Fruit> fruitBowl = bunchOfBananas;
}
}
Tekpub–Jon Skeet–Builder Pattern http://www.programgood.net/PermaLink,guid,9cb222d4-ec06-495b-b053-e5fa1b84cbb2.aspx 2012-05-19T12:33:42.3690609-04:00 2012-05-19T12:33:42.3690609-04:00

When constructors get out of control and Factory gets cumbersome.

[TestFixture]
publicclassBuilderTests
{
[Test]
publicvoid BuilderPattern()
{
Period period = Period.FromHours(5);
//gets longwinded
period = Period.FromHours(5) + Period.FromMinutes(3);

//mandatory stuff in constructor
//eg if this were an EmailBuilder then to, from etc..
//PeriodBuilder builder = new PeriodBuilder();
////option stuff
//builder.Hours = 5;
//builder.Minutes = 3;
//Period built = builder.Build();

//using object initialiser syntax C#3
Period built = newPeriodBuilder { Hours = 5, Minutes = 3 }.Build();

//this wont change anything
//builder.Seconds = 10;
Assert.AreEqual(0, built.Seconds);
Assert.AreEqual(built, period);
}
}
Tekpub8–Jon Skeet–Factory Pattern http://www.programgood.net/PermaLink,guid,e4065768-8468-4a93-b10b-01517da211b4.aspx 2012-05-18T22:39:06.4375-04:00 2012-05-18T22:39:06.4375-04:00
//this is an immutable type
public sealed class Point
{
//field
privatereadonlyint x;
privatereadonlyint y;

//property
publicint X { get { return x; } }
publicint Y { get { return y; } }

public Point(int x, int y)
{
this.x = x;
this.y = y;
}
}

asdf

public struct BadDuration
{
privatereadonlylong seconds;
privatereadonlylong milliseconds;
privatereadonlylong ticks;

//multiple constructors are a code smell and can mean you're trying to do too much with a single class or struct
public BadDuration(long ticks)
{
this.ticks = ticks;
}

public BadDuration(long milliseconds)
{
this.ticks = milliseconds * 10000;
}

public BadDuration(long seconds)
{
this.ticks = seconds * 10000 * 1000;
}
}

wont compile as signatures are the same eg all are longs

public struct BadDuration
{
//fields
//private readonly long seconds;
//private readonly long milliseconds;
privatereadonlylong ticks;

//property
publiclong Ticks { get { return ticks; } }

//this works in a class.. sort of immutable

//multiple constructors are a code smell and can mean you're trying to do too much with a single class or struct
private BadDuration(long ticks)
{
this.ticks = ticks;
}

publicstaticBadDuration FromTicks(long ticks)
{
returnnewBadDuration(ticks);
}

//the classic Factory pattern that can help clear up a constructor overload mess. downside is requires a knowledge of your api.
publicstaticBadDuration FromMilliseconds(long milliseconds)
{
returnnewBadDuration(milliseconds * 10000);
}

publicstaticBadDuration FromSeconds(long seconds)
{
returnnewBadDuration(seconds * 10000 * 1000);
}
}

//immutable - state cannot be modified after it has been created
[TestFixture]
publicclassSimpleImmutability
{
[Test]
publicvoid FromSeconds()
{
BadDuration duration = BadDuration.FromMilliseconds(5);
Assert.AreEqual(50000, duration.Ticks);
}

[Test]
publicvoid Ticks()
{
BadDuration duration = BadDuration.FromTicks(10);
Assert.AreEqual(10, duration.Ticks);
}
}

very interesting code with with classic Factory pattern.  Very nice way of easily making objects.

Tekpub 7–Jon Skeet–Open/Closed Principle and Liskov Substitution http://www.programgood.net/PermaLink,guid,80a44ba0-6ba6-4ad4-8c2e-16e846b674f3.aspx 2012-05-18T22:16:14.828125-04:00 2012-05-18T22:16:14.828125-04:00

SOLID Principles (Uncle Bob)

Single Responsibility – Epi 6

Open / Closed – 7

Liskov Substitution – 7

Interface Segregation – 2

Dependency Inversion – 3 and 4

 

Open/Closed Principle

Change is inevitable in software, but when we change this chaotically we get chaotic results.

Must easier to think of complex system of small bits, which are tested well, then we put them together.

When a class is ‘done’.. it is

  • Open for extension
  • Closed for modification

ie don’t touch stuff that works

maybe derived from class… or chage source code of class… just don’t change behaviour

Barbara Liskovs Substitution Principle

all about inheritance.

eg I should be able to use any implementation of IClock without knowing which one I’m using

 

Software engineering is a tradeoff… pragmatic rather than dogmatic

Jon – inheritance should be used judiciously!

internal and sealed classes….

System.Web is notorious for hiding classes making is very difficult to test

HttpContext has caused many sleepless nights.

“Deisgn for inheritance or prohibit it”

public class Point
{
publicint X { get; set; }
publicint Y { get; set; }
}

//I haven't put the time into figuring out what this class should do under
//inheritance
//public sealed class Liskov
publicclassLiskov
{
//Virtual methods and properties in base classes
//REQUIRE derived classes to use the ?override? keyword when, well, overriding said methods and properties

//document what it does, not how it achieves it
//ignoring derived.. Foo is going to return hello, Bar is going to return hello there
//noone else should care
publicvirtualstring FormatPoint(Point point)
{
return FormatPoint(point.X, point.Y);
}

publicvirtualstring FormatPoint(int x, int y)
{
returnstring.Format("x={0}, y={1}", x, y);
}
}

//person deriving here, won't know they've changed Bars behaviour too
publicclassBreakage : Liskov
{
publicoverridestring FormatPoint(int x, int y)
{
returnbase.FormatPoint(x, y) + "<====";
}
}
Tekpub 6–Jon Skeet–Single Responsibility and Type Meaning http://www.programgood.net/PermaLink,guid,8c565a08-afc9-49b7-a0b1-a7efda897655.aspx 2012-05-18T21:27:16.515625-04:00 2012-05-18T21:27:16.515625-04:00

Designing types and using types.

“Single Responsibility Principle” every class should be responsible for only one thing.  Part of this is being completely clear about what the class does

Try to have types that represent what you want them to.

Summary for DateTime:

  • can’t represent just a date
  • can’t represent just a time of day
  • got to use same time whether universal time, this computer, another timezone
 TekPub4–IoC continued http://www.programgood.net/PermaLink,guid,afbde867-9ae7-4726-a8ac-7a1f7f2c9a9d.aspx 2012-05-18T18:33:20.515625-04:00 2012-05-18T18:33:20.515625-04:00

In addition to handling instance construction, Inversion of Control containers can also handle lifetime and scope for you.

image

//.InSingletonScope resolve it later on, but resolve it only once, use the same instance after that.
//injector.Bind<IClock, SystemClock>().InSingletonScope();

.InSingletonScope resolve it later on, but resolve it only once, use the same instance after that.

Testability!

singletons – global state is the enemy of simplicity! let IoC containers do stuff.

logging is okay as its fine generally to have all the system call into the same logger

for the clock – Jon is always using an interface, and DI.

TekPub4 and 5–Jon Skeet–IoC http://www.programgood.net/PermaLink,guid,fb929952-3bbf-4110-8adf-bd1e6d02c178.aspx 2012-05-18T17:22:46.921875-04:00 2012-05-18T18:14:15.125-04:00

Taking the manually done dependency injection and using a factory now (then go away from factory to home grown  IoC)

//is this unneeded complexity if its a smaller app? Actually this is a Factory
//jon recommends if can keep in main method, then keep manual DI.
class Injector
{
//getting ugly as can be literally 100's of dependencies
publicIClock CreateClock()
{
//a singleton
returnSystemClock.Instance;
}

publicLicence CreateLicence()
{
returnnewLicence(Instant.UnixEpoch, CreateClock());
}

publicDateTimeZone CreateTimeZone()
{
returnDateTimeZone.GetSystemDefault();
}

publicCalendarSystem CreateCalendarSystem()
{
returnCalendarSystem.Iso;
}

publicDiary CreateDiary()
{
returnnewDiary(CreateClock(), CreateCalendarSystem(), CreateTimeZone());
}

publicDiaryPresenter CreateDiaryPresenter()
{
returnnewDiaryPresenter(CreateDiary(), CreateLicence());
}
}

 

and then:

static void Main()
{
// newing up the factory
Injector injector = newInjector();
var presenter = injector.CreateDiaryPresenter();
presenter.Start();
}

outtake to video 5..outtake…IoC.  Basically wanting to make things more generic:

structuremap, ninject, autofac, Unity are IoC

eg in an MVC app I  http://www.programgood.net/2011/09/20/VidPub1SettingUpSolution.aspx:

“Every time you see a request for ILogger interface in a controller, return a new NLogger class” 

kernel.Bind<ILogger>().To<NLogger>();
[TestFixture]
publicclassProgram
{
[Test]
publicvoid MainTest()
{
//manually setting up the dependencies
IClock clock = SystemClock.Instance;
Diary diary = newDiary(clock, CalendarSystem.Iso, DateTimeZone.GetSystemDefault());
//licence expired in 1970, and current time is systemclock time
Licence licence = newLicence(Instant.UnixEpoch, clock);
var presenter = newDiaryPresenter(diary, licence);
presenter.Start();

//IoC
//Injector injector = new Injector();
//injector.Bind<IClock, SystemClock>();
//injector.Bind<DateTimeZone>(DateTimeZone.GetSystemDefault());
//injector.Bind<Instant>(Instant.FromUtc(2000,1,1,0,0,0));
//injector.Bind<CalendarSystem>(CalendarSystem.Iso);

////you've got all these things.. now do stuff please
//var presenter = injector.Resolve<DiaryPresenter>();
//presenter.Start();


}
}

classDiaryPresenter
{
privatereadonlyDiary diary;
privatereadonlyLicence licence;

public DiaryPresenter(Diary diary, Licence licence)
{
this.diary = diary;
this.licence = licence;
}

publicvoid Start()
{
Console.WriteLine("Today is {0}", diary.FormatToday());
Console.WriteLine("Licence expired? {0}", licence.HasExpired);
}
}

classLicence
{
//fields
privatereadonlyInstant expirey;
privatereadonlyIClock clock;

public Licence(Instant expirey, IClock clock)
{
//variables or local variables
this.expirey = expirey;
this.clock = clock;
}

//property
publicbool HasExpired
{
get { return clock.Now >= expirey; }
}
}

//calendaring application which will want to know what time it is too!
classDiary
{
privatereadonlyLocalDatePattern outputPattern = LocalDatePattern.CreateWithInvariantInfo("yyyy-MM-dd");
//fields
privatereadonlyIClock clock;
privatereadonlyCalendarSystem calendar;
privatereadonlyDateTimeZone timeZone;

//by demanding the dependencies in the constructor, classes are more flexible
//especially if they are interfacess
public Diary(IClock clock, CalendarSystem calendar, DateTimeZone timeZone)
{
this.clock = clock;
this.calendar = calendar;
this.timeZone = timeZone;
}

publicstring FormatToday()
{
//in system default timezone, and system default calendar
//DateTime dateTime = DateTime.Today;
LocalDate date = clock.Now.InZone(timeZone, calendar).LocalDateTime.Date;
if (date.Month == 4)
{ //ncrunch showing black here - so tests are not covering this codepath
return"April fool";
}
return outputPattern.Format(date);
}
}

A working version of the code with manual DI.

class Program
{
staticvoid Main(string[] args)
{
//manually setting up the dependencies
IClock clock = SystemClock.Instance;
Diary diary = newDiary(clock, CalendarSystem.Iso, DateTimeZone.GetSystemDefault());
//licence expired in 1970, and current time is systemclock time
Licence licence = newLicence(Instant.UnixEpoch, clock);
var presenter = newDiaryPresenter(diary, licence);
presenter.Start();


Console.WriteLine("Type in 1 for good licence, 2 for expired");
string userInput = Console.ReadLine();
if (userInput == "1")
{
//really need public properties on licence to reset it rather than instantiating a new one!
licence = newLicence(Instant.FromUtc(2020,1,1,0,0,0), clock);
presenter = newDiaryPresenter(diary, licence);
}
Console.WriteLine("License expiredx: {0}", licence.HasExpired);
Console.ReadLine();
}
}

Made a new console project referencing the class project.  Proves that it does work as a real application and not just in test.

class Injector
{
//going to be able to bind by instance and by type
//where TConcrete derives from TKey
//TKey is going to be what we provide

//from type to a way of getting to an instance of that type
privateDictionary<Type,Func<object>> providers = newDictionary<Type, Func<object>>();

//eg whenever you want IClock, use the SystemClock type
publicvoid Bind <TKey, TConcrete>() where TConcrete : TKey
{
//where we're
providers[typeof(TKey)] = () => ResolveByType(typeof(TConcrete));
}

privateobject ResolveByType(Type type)
{
Console.WriteLine("Resolving...{0}", type);
//assume we're got a single constructor in the type we're passing in
var constructor = type.GetConstructors().SingleOrDefault();
//if we don't have a constructor then maybe a static method
if (constructor != null)
{
//want to invoke the constructor, but need to resolve all of its dependencies
//eg when we ask for a diary, get me a clock, get me a calendar, get me a timezone
var arguments = constructor.GetParameters()
.Select(parameterInfo => Resolve(parameterInfo.ParameterType))
.ToArray();
return constructor.Invoke(arguments);
}
//Instance is a property on system clock
//we're trying to find something on systemclock... however it was a field, thats why GetProperty wasn't returning it.
//var instanceProperty = type.GetProperty("Instance", BindingFlags.Public | BindingFlags.Static);
var instanceField = type.GetField("Instance");
return instanceField.GetValue(null);
}

publicvoid Bind<T>(T instance)
{
//returns the instance
providers[typeof(T)] = () => instance;
}

internal TKey Resolve<TKey>()
{
return (TKey)Resolve(typeof(TKey));
}

//how do we resolve something?
internalobject Resolve(Type type)
{
Func<object> provider;

if (providers.TryGetValue(type, out provider))
{
return provider();
}
return ResolveByType(type);
}
}

need to come back to this and understand**

NTP Time Server Monitor http://www.programgood.net/PermaLink,guid,53d87f43-44e2-40ae-88da-7d9fb40894af.aspx 2012-05-17T15:41:36.9375-04:00 2012-05-17T15:50:56.84375-04:00

image

To get to this screen, press the icon on NTP Status tab.

needs port UDP 123 opened inbound

http://serverfault.com/questions/390061/windows-7-as-ntp-time-server

useful to sync up local servers clock with the ntpd service ie clock, internet time, point to localhost.

TekPub 3–Jon Skeet–Dependency Injection manually http://www.programgood.net/PermaLink,guid,73d3a976-570c-438f-a905-d86a715e8bc8.aspx 2012-05-16T23:03:46.578125-04:00 2012-05-16T23:03:46.578125-04:00

Any time you instantiate or reference a concrete type within a class, you take a Dependency and make your code harder to test.

public Licence(Instant expirey, IClock clock)
{
//variables or local variables
this.expirey = expirey;
this.clock = clock;
}

we are injecting a dependency here.  More loosely bound here than


public Licence(Instant expirey)
{
//variables or local variables
this.expirey = expirey;
this.clock = SystemClock.Instance;
}

tightly bound to a concrete implementation here.

We made another class here called Diary which uses a clock too:

//calendaring application which will want to know what time it is too!
class Diary
{
privatereadonlyLocalDatePattern outputPattern = LocalDatePattern.CreateWithInvariantInfo("yyyy-MM-dd");
//fields
privatereadonlyIClock clock;
privatereadonlyCalendarSystem calendar;
privatereadonlyDateTimeZone timeZone;

//by demanding the dependencies in the constructor, classes are more flexible
//especially if they are interfacess
public Diary(IClock clock, CalendarSystem calendar, DateTimeZone timeZone)
{
this.clock = clock;
this.calendar = calendar;
this.timeZone = timeZone;
}

publicstring FormatToday()
{
//in system default timezone, and system default calendar
//DateTime dateTime = DateTime.Today;
LocalDate date = clock.Now.InZone(timeZone, calendar).LocalDateTime.Date;
if (date.Month == 4)
{ //ncrunch showing black here - so tests are not covering this codepath
return"April fool";
}
return outputPattern.Format(date);
}
}

 

//still a class lib so can't run it.. demonstrates concept
public class Program
{
staticvoid Main()
{
//manual dependency injection - this takes a lot of time and code to do
//so people invented dependency injection frameworks aka Inversion of Control.
IClock clock = SystemClock.Instance;

Licence licence = newLicence(Instant.UnixEpoch, clock);
Diary diary = newDiary(clock,CalendarSystem.Iso, DateTimeZone.GetSystemDefault());

DiaryPresenter presenter = newDiaryPresenter(diary, licence);
}
}

classDiaryPresenter
{
public DiaryPresenter(Diary diary, Licence licence)
{
}
}

classLicence
{
privatereadonlyInstant expirey;
privatereadonlyIClock clock;

public Licence(Instant expirey, IClock clock)
{
//variables or local variables
this.expirey = expirey;
this.clock = clock;
}

//property
publicbool HasExpired
{
get { return clock.Now >= expirey; }
}
}

//calendaring application which will want to know what time it is too!
classDiary
{
privatereadonlyLocalDatePattern outputPattern = LocalDatePattern.CreateWithInvariantInfo("yyyy-MM-dd");
//fields
privatereadonlyIClock clock;
privatereadonlyCalendarSystem calendar;
privatereadonlyDateTimeZone timeZone;

//by demanding the dependencies in the constructor, classes are more flexible
//especially if they are interfacess
public Diary(IClock clock, CalendarSystem calendar, DateTimeZone timeZone)
{
this.clock = clock;
this.calendar = calendar;
this.timeZone = timeZone;
}

publicstring FormatToday()
{
//in system default timezone, and system default calendar
//DateTime dateTime = DateTime.Today;
LocalDate date = clock.Now.InZone(timeZone, calendar).LocalDateTime.Date;
if (date.Month == 4)
{ //ncrunch showing black here - so tests are not covering this codepath
return"April fool";
}
return outputPattern.Format(date);
}
}

Manually doing dependency injection.  Setting up each component explicitly.  Each is loosely coupled

Licences don’t know about Diaries

Diaries don’t know about Licences..

DiaryPresenter knows about diary and licence, but not about a clock or timezone directly.

notice SystemClock.Instance is a singleton.

can get very hard to maintain

Tekpub–Jon Skeet–Interfaces http://www.programgood.net/PermaLink,guid,5c06637b-c987-40bf-9c40-37f8336b9de1.aspx 2012-05-16T17:48:48.140625-04:00 2012-05-16T18:23:00.734375-04:00

Why are interfaces important?

not a pattern.. a language feature.

time zone changes..

We want to give the current Date and Time as a dependency.. so can test properly eg

what if our licence never expires in following 5 years.. want to inject what would happen in the future,  and using DateTime.Now in our licence code means can’t test that.

[TestFixture]
publicclassLicenceTests
{
[Test]
publicvoid HasExpired_AnExpiredDate_ReturnFalse()
{
Licence licence = newLicence(newDateTime(2000,1,1,0,0,0));
Assert.IsTrue(licence.HasExpired);
}

[Test]
publicvoid HasExpired_AFutureDate_ReturnTrue()
{
Licence licence = newLicence(newDateTime(2020, 1, 1, 0, 0, 0));
Assert.IsFalse(licence.HasExpired);
}
}

classLicence
{
//field
privatereadonlyDateTime expirey;

public Licence(DateTime expirey)
{
//expirey is a variable or local variable
this.expirey = expirey;
}

//property
publicbool HasExpired
{
//a dependency on a static method
//nothing we can do to make it behave differtly in tests
get { returnDateTime.UtcNow > expirey; }
}
}

 

StubClock and SystemClock both implement IClock

public interface IClock
{
///<summary>
/// Gets the current <see cref="Instant"/> on the time line according to this clock.
///</summary>
Instant Now { get; }
}

so thats how this code uses interfaces.. for testing we’ve got a StubClock that we can set the time on.  For production we pass in the actual time.

[TestFixture]
publicclassLicenceTests
{
[Test]
publicvoid HasExpired_AnExpiredDate_ReturnTrue()
{
Instant expirey = Instant.FromUtc(2000, 1, 1, 0, 0, 0);
StubClock clock = newStubClock(expirey + Duration.FromTicks(1));

//injecting the dependency
Licence licence = newLicence(expirey, clock);

Assert.IsTrue(licence.HasExpired);
}

[Test]
publicvoid HasExpired_AFutureDate_ReturnTrue()
{
Instant expirey = Instant.FromUtc(2000, 1, 1, 0, 0, 0);
StubClock clock = newStubClock(expirey - Duration.FromTicks(1));

Licence licence = newLicence(expirey, clock);

Assert.IsFalse(licence.HasExpired);
}

[Test]
publicvoid HasExpired_AtExactInstant_ReturnTrue()
{
Instant expirey = Instant.FromUtc(2000, 1, 1, 0, 0, 0);
StubClock clock = newStubClock(expirey);

Licence licence = newLicence(expirey, clock);

Assert.IsTrue(licence.HasExpired);
}

[Test]
publicvoid HasExpired_NonExpiredLicenceBecomesExpires_ReturnTrue()
{
Instant expirey = Instant.FromUtc(2000, 1, 1, 0, 0, 0);
StubClock clock = newStubClock(expirey - Duration.FromTicks(1));

Licence licence = newLicence(expirey, clock);

Assert.IsFalse(licence.HasExpired);
clock.AdvanceTicks(1);
Assert.IsTrue(licence.HasExpired);
}
}

classLicence
{
privatereadonlyInstant expirey;
privatereadonlyIClock clock;

public Licence(Instant expirey, IClock clock)
{
//variables or local variables
this.expirey = expirey;
this.clock = clock;
}

//property
publicbool HasExpired
{
get { return clock.Now >= expirey; }
}
}

publicclassBigApplicatiion
{
staticvoid Main ()
{
//a natural singleton! there is only 1 system clock
//but there is no way to test this business code...want dependency injection
Licence licence = newLicence(Instant.FromUtc(2012,4,19,0,0), SystemClock.Instance);
if (licence.HasExpired)
{
Console.WriteLine("Licence expired");
return;
}
}
}
NCrunch–Automated Testing http://www.programgood.net/PermaLink,guid,d48a6ac1-12a9-4875-98f0-6cc524809337.aspx 2012-05-16T17:42:36.09375-04:00 2012-05-16T17:42:36.09375-04:00

http://www.ncrunch.net/download.htm

image

Just sits there and runs any test that I change.

TekPub Design Patterns Jon Skeet–Singleton http://www.programgood.net/PermaLink,guid,8b56021a-98e4-44b1-a138-0052459da335.aspx 2012-05-16T15:52:47.171875-04:00 2012-05-16T16:49:51.078125-04:00

Singleton: A class which only allows a single instance

Very controversial in general.

NodaTime – Jons open source library, which implements good practices

namespace Sandbox
{
publicclassSingleton
{
publicvoid DoSomething()
{
}
}

publicclassSingletonClient
{
publicvoid UseSingleton()
{
Singleton s1 = newSingleton();
s1.DoSomething();
Singleton s2 = newSingleton();
s2.DoSomething();
}
}
}

Ahh – can make 2 of the singleton class!

public static class Singleton
{
publicstaticvoid DoSomething()
{
}
}

publicclassSingletonClient
{
publicvoid UseSingleton()
{
//Singleton s1 = new Singleton();
//s1.DoSomething();
//Singleton s2 = new Singleton();
//s2.DoSomething();
Singleton.DoSomething();
}
}

but want to instantiate class.. just not have 2 possible

public class Singleton
{
//global state - bad
privatestaticSingleton instance;

private Singleton()
{
}

publicstaticSingleton CreateInstance()
{
if (instance == null)
{
instance = newSingleton();
}
return instance;
}

//raison d'etre for the class
publicvoid DoSomething()
{
}
}

[TestFixture]
publicclassSingletonClient
{
[Test]
publicvoid UseSingleton()
{
Singleton s1 = Singleton.CreateInstance();
Singleton s2 = Singleton.CreateInstance();
Assert.AreSame(s1,s2);
}
}

However if on multiple threads this could be bad as both could get to the new Singleton() line at the same time.

mutex locks..complex

public class Singleton
{
//clr manages locking, mutex and volatile stuff
privatestaticreadonlySingleton instance = newSingleton();

//empty static constructor - chaanges when the clr is allowed to initialise this...
//will only initialise before it is first used.
static Singleton() {}

private Singleton()
{
//stuff that must only happen once
Console.WriteLine("Singleton constructor");
}

publicstaticSingleton Instance { get { return instance; } }

publicstaticvoid SayHi()
{
Console.WriteLine("hi");
}

//raison d'etre for the class
publicvoid DoSomething()
{
// This must be thread-safe... it can be got at from multiple threads... thats its purpose
}
}

[TestFixture]
publicclassSingletonClient
{
[Test]
publicvoid UseSingleton()
{
Singleton.SayHi();
Console.WriteLine("Start of test");
Singleton s1 = Singleton.Instance;
Singleton s2 = Singleton.Instance;
Assert.AreSame(s1,s2);
}
}

asdf

image

but say we wanted real laziness ie only creating the singleton when needed:

public class Singleton
{
//nested class
privatestaticclassSingletonHolder
{
internalstaticreadonlySingleton instance = newSingleton();
//empty static constructor - forces laziness!
static SingletonHolder() {}
}

private Singleton()
{
//stuff that must only happen once
Console.WriteLine("Singleton constructor");
}

publicstaticSingleton Instance { get { returnSingletonHolder.instance; } }

publicstaticvoid SayHi()
{
Console.WriteLine("hi");
}

//raison d'etre for the class
publicvoid DoSomething()
{
// This must be thread-safe... it can be got at from multiple threads... thats its purpose
}
}

[TestFixture]
publicclassSingletonClient
{
[Test]
publicvoid UseSingleton()
{
Singleton.SayHi();
Console.WriteLine("Start of test");
Singleton s1 = Singleton.Instance;
Singleton s2 = Singleton.Instance;
Assert.AreSame(s1,s2);
}
}

.NET4 could use Lazy<T>

SpaceBlock–Viewing Amazon S3 http://www.programgood.net/PermaLink,guid,64eaa317-8d56-499a-8a20-87a6fece6042.aspx 2012-05-15T14:36:48.625-04:00 2012-05-15T14:36:48.625-04:00

Do be able to multiple delete files in a folder

image

Scrum http://www.programgood.net/PermaLink,guid,585601a5-8c09-482c-aeb9-db96005d7dcd.aspx 2012-05-07T14:12:41.43575-04:00 2012-05-07T14:12:41.43575-04:00

From wikipedia:

During the meeting, each team member answers three questions:[11]

  • What have you done since yesterday?
  • What are you planning to do today?
  • Any impediments/stumbling blocks?
 Web Design http://www.programgood.net/PermaLink,guid,ce3587ec-01d6-499b-8a7d-59a2340510a4.aspx 2012-05-04T07:29:37.189-04:00 2012-05-04T07:29:37.189-04:00

http://www.artisteer.com/

http://www.drowningintechnicaldebt.com/ShawnWeisfeld/archive/2011/08/28/create-a-template-for-orchard.aspx

Orchard–Setting Up Portfolio Website http://www.programgood.net/PermaLink,guid,a5ea8e71-76ec-46b5-822b-c34a64479a21.aspx 2012-04-17T08:57:42.941875-04:00 2012-04-17T08:57:42.941875-04:00

Goals:
    website demoing projects I've done over many years
        to give people ideas about what can be done easily
        to sell myself
        for it to become my 'CV'
            look at stackoverflow CV - link to it
            actual CV - link to it
       
    CMS that I can use in many places
    large codebase to explore

Examples

image

nice and simple.

Orchard Reference Sites http://www.programgood.net/PermaLink,guid,e5ec86e5-7977-4bec-bfc1-be97efdaee09.aspx 2012-04-17T08:55:53.5825-04:00 2012-04-17T08:56:04.55125-04:00

Also good ref sites are: www.johnpapa.net

http://skywalkersoftwaredevelopment.net/blog/writing-an-orchard-webshop-module-from-scratch-part-1

Orchard Performance http://www.programgood.net/PermaLink,guid,f0426fba-7042-4ad6-bd6a-73af77e6a4f0.aspx 2012-04-17T08:55:15.441875-04:00 2012-04-17T08:55:15.441875-04:00

image_thumb[11]

and have turned off worker process recycling in Performance too.

Trust level is set to full in web.config, and debug is set to false.

Customising Orchard http://www.programgood.net/PermaLink,guid,ff505b42-0865-4037-9705-5fc9a1367c3f.aspx 2012-04-17T08:54:25.48875-04:00 2012-04-17T08:54:25.48875-04:00

From 4 part video by Brent Arias http://www.ariasamp.net/ linked on www.orchardproject.net

image

adding in a subtitle to the minty theme

Downloading Modules – Bing Maps and Image Gallery

Adding them into the page via Widgets again:  (found that with Multiple themese installed, I had to disable other themes and only have the enabled one that I want to work).

Image Gallery

image

impressive and has nice lightbox feature.

Trying to go live – have copied the database up to live using generate scripts and this to do a complete blank of the tables:

exec sp_msforeachtable 'DROP TABLE ?'

want to exclude settings.txt when I do a deploy as it overwrites the db connection string on the live server.

image

bin\orchard

if problems then can remove stuff from here.

Content Types

image

going into Content Types, Blog

image

adding a Body part which allows us to use html

Added in a blog, and a blog post.  However only get the first 120 characters of the blog and not the whole article which is annoying.

image

Add in Designer Tools – going for a Shape Tracing feature.

image

shape tracing

Content Type

image

now can see the entire blogpost

Top Level Zones / Content Types / Local Zones

Keep changes in a theme (or ideally a new one)

No Tags

image

change footer:31 to -

No Comments

image

but this is in the Module..bad practice to edit directly.

image

Footer is the zone.

Layers

image

Creating a custom layer so that the image gallery will display only when the user is authenticated and not on home page.

Users

Add new users into Roles which are settable.  The roles just are reallly what is allowed in the back end.

If want users to see different content on the front end then look at module Quanta

Eventing / Messaging

.. eg if anyone leaves a comment then we want an email.

Book Review Widget

Content Type has Content Parts

image

content type is book review, content parts are: Body, Containable (lists) and Tags

image

have added 2 custom fields

Orchard Deployment from Source http://www.programgood.net/PermaLink,guid,ada43cf5-b0bf-438c-84f8-3502f32c4777.aspx 2012-04-17T08:35:32.035625-04:00 2012-04-17T08:35:32.035625-04:00

rom VS2010 command prompt.. build “compile;package” from c:\dev\orchard\hg

then package is … but got issues with newly installed image modules

error when building and using imagegallery.

Tried disabling it on the interface and removing from front end, however it is still in the solution.

http://stefantsov.com/msbuild-and-msdeploy-for-orchard – deploying with MSBUILD

image_thumb5_thumb

used to be all files in this project folder.. now all files in project.

http://orchard.codeplex.com/discussions/350016 – Bertrand describes how he deploys using webdeploy.

http://orchard.codeplex.com/discussions/283821 – looks like it should work!

Make sure connection string settings are correct on the server, otherwise will get a 404 error!

look in Logs

DataConnectionString: Data Source=.\SQLEXPRESS;Initial Catalog=orcharddb;Persist Security Info=True;User ID=orcharddb;Password=secret

Connecting to SQL Server on EC2 http://www.programgood.net/PermaLink,guid,29f49793-0b91-4f43-ae99-fcecc9dadbf0.aspx 2012-04-16T06:15:52.3325-04:00 2012-04-16T06:15:52.3325-04:00

As I’ve got an MSDE instance running on .\ which is listening on 1433 so maybe my setup was a bit more complex than usual.

image

setup TCP/IP on the server for another port. (it had a blank port to begin with)

Open up the firewall on EC2

image

Connection string in SQL Management Studio:

404 Error when Deploying Orchard from Visual Studio http://www.programgood.net/PermaLink,guid,4e0e5d4a-b17d-4f38-8579-e75df3d23c60.aspx 2012-04-16T04:53:52.910625-04:00 2012-04-16T04:53:52.910625-04:00

I was getting nothing.  Turned out to be the connection string on the live server wasn’t right.

To see the error look in App_Data\Logs

To change connection string look in \App_Data\Sites\Default\Settings.txt