Suggested additions to the repo

Markdown/CommonTasks/ct1.md

@@ -0,0 +1,108 @@
+# Common Tasks: Validating String Length
+
+Inevitably almost every developer will be faced with the necessity to validate the length of a string prior to doing something with it, an obvious case in point would be specifying criteria for a password.
+
+At this point it's not uncommon for new or relatively inexperienced developers to create a simple checking method to satisfy the immediate requirement.
+
+```c#
+bool ValidateString(string input)
+{
+    return input.length < 10 && input.length > 16;
+}
+```
+
+If the requirement was that the string be no less than 10 characters in length and no more than 16 then undeniably it will produce a result. If at some point further on in the program another similar check is required then it's very easy to see how this might be copied and pasted with a a couple of alterations to match the next requirement.
+
+Using Metalama this task can be easily solved, as it has a number of pre-made contracts for just this type of scenario.
+
+You could write code as follows (using a simple console application as an example);
+
+```c#
+using Metalama.Patterns.Contracts;
+
+namespace CommonTasks
+{
+    internal class Program
+    {
+
+        [StringLength(10, 16)]
+        private static string? password;
+
+        static void Main(string[] args)
+        {
+            try
+            {
+                Console.WriteLine("Enter your Password:  ");
+                password = Console.ReadLine();
+                Console.WriteLine("Your password meets the basic length requirement.");
+            } catch(ArgumentException ex)
+            {
+                Console.WriteLine(ex.Message);
+            }
+        }
+    }
+}
+```
+
+Metalama's StringLength aspect takes as parameters either a maximum, or a minimum and maximum length and in the event of a validation failure throws a System.ArgumentException.
+
+At the point of compilation it adds the necessary logic into your code.
+
+```c#
+using Metalama.Patterns.Contracts;
+
+namespace CommonTasks
+{
+    internal class Program
+    {
+
+
+        private static string? _password1;
+
+
+        [StringLength(10, 16)]
+        private static string? password
+        {
+            get
+            {
+                return Program._password1;
+
+
+            }
+            set
+            {
+                if (value != null && (value!.Length < 10 || value.Length > 16))
+                {
+                    throw new ArgumentException($"The  'password' property must be a string with length between {10} and {16}.", "value");
+                }
+                Program._password1 = value;
+
+
+            }
+        }
+        static void Main(string[] args)
+        {
+            try
+            {
+                Console.WriteLine("Enter your Password:  ");
+                password = Console.ReadLine();
+                Console.WriteLine("Your password meets the basic length requirement.");
+            }
+            catch (ArgumentException ex)
+            {
+                Console.WriteLine(ex.Message);
+            }
+        }
+    }
+}
+```
+
+The benefit of using Metalama to handle such tasks is that they are handled consistently whilst your own code remains concise, easy to read and comprehend.
+
+<br>
+
+If you'd like to know more about Metalama in general then visit our [website](https://www.postsharp.net/metalama).
+
+You can learn more about Metalama contracts [here](https://doc.postsharp.net/metalama/patterns/contracts).
+
+Why not join us on [Slack](https://www.postsharp.net/slack) where you can keep up with what's new and get answers to any technical questions that you might have.

Markdown/CommonTasks/ct2.md

@@ -0,0 +1,103 @@
+# Common Tasks: Meeting Requirements
+
+It's not uncommon for developers to have to ensure that certain key properties or return values actually have a value. Although the code required to perform the checks needed to ensure that a value is present are not difficult to write they do have the effect of of making your code look cluttered.
+
+A typical string property might end up looking like this.
+
+```c#
+public class ApplicationUser
+{
+    private string userName;
+
+    public string UserName
+    {
+        get { return userName; }
+        set
+        {
+            if (!string.IsNullOrWhiteSpace(value))
+            {
+                userName = value;
+            }
+            else
+            {
+                throw new ArgumentException("Invalid value for MyString. Value must not be null or blank.");
+            }
+        }
+    }
+}
+```
+
+Metalama can make this task much simpler. Using exactly the same string property as an example you would just require the following.
+
+```c#
+using Metalama.Patterns.Contracts;
+
+namespace CommonTasks.Required
+{
+    public class ApplicationUser
+    {
+        [Required]
+        public string UserName { get; set; }
+
+    }
+}
+```
+
+Not only is the code cleaner but it is immediately apparent to anyone reading it that the UserName property is actively required in the overall working of the application. That is something that cannot be inferred as quickly by looking at the first example.
+
+At compile time Metalama will add all the code that is necessary to ensure that the UserName property must be present.
+
+```c#
+using Metalama.Patterns.Contracts;
+
+namespace CommonTasks.Required
+{
+    public class ApplicationUser
+    {
+        private string _userName = default!;
+
+        [Required]
+        public string UserName
+{
+            get
+            {
+                return this._userName;
+
+
+            }
+            set
+            {
+                if (string.IsNullOrWhiteSpace(value))
+                {
+                    if (value == null!)
+                    {
+                        throw new ArgumentNullException("value", "The 'UserName' property is required.");
+                    }
+                    else
+                    {
+                        throw new ArgumentOutOfRangeException("value", "The 'UserName' property is required.");
+                    }
+                }
+                this._userName = value;
+
+
+            }
+        }
+    }
+}
+
+```
+
+Metalama has actually reinforced the check on our behalf ensuring that there is a clear distinction between a null value being passed to the property and a simple space making it easier to diagnose errors.
+
+Metalama has a wide range of pre-built contracts that you can use in situations like this where it is necessary to ensure that fields, properties, parameters or return values meet certain conditions. In every case all you need to do is add the relevant attribute to you code in the correct place and Metalama will add the necessary additional code at compile time. Examples include phone, email and credit card number checks to name but three.
+
+Doing this manually is time consuming and it can be prone to error. Metalama removes the chore of writing repetitive code, makes your intention clearer to anyone else who reads your code at a later date and leaves you safe in the knowledge that it will just work as it should when required.
+
+<br>
+
+If you'd like to know more about Metalama in general then visit our [website](https://www.postsharp.net/metalama).
+
+You can learn more about Metalama contracts [here](https://doc.postsharp.net/metalama/patterns/contracts).
+
+Why not join us on [Slack](https://www.postsharp.net/slack) where you can keep up with what's new and get answers to any technical questions that you might have.

Markdown/CommonTasks/ct3.md

@@ -0,0 +1,80 @@
+# Common Tasks: INotifyPropertyChanged
+
+We have come to expect application user interfaces to respond almost instantaneously to data that we input into them. This has been made possible by UI's that are built around data bound controls in architecture that implements patterns such as MVVM (Model, View, ViewModel).
+
+In simple language this works because the UI is able to update when properties in the underlying data models change and in so doing raise the PropertyChanged event. This logic is encapsulated in the INotifyPropertyChanged interface. This pattern has been widely adopted because one of the major benefits that it provides is the ability to reuse data models with different Different views.
+
+There is however one very notable drawback to using this interface. It requires a great deal of repetitive boiler plate code and that code is not produced automatically so it's possible to omit parts of it unintentionally.
+
+Dot Net already has an INotifyPropertyChanged Interface so why not just use that. The drawback to that approach is illustrated below.
+
+<br>
+
+![](images/ct1.gif)
+
+<br>
+
+The standard Visual Studio intellisense for this barely does anything. There is still a need to adjust the properties so that they actually raise the event and the event itself needs to be handled.
+
+If Metalama is used to implement INotifyPropertyChanged then all of the additional code required to make this work will be taken care of. It will be necessary to create an aspect to do this but fortunately there is a great example of such an aspect in the [Metalama Documentation](https://doc.postsharp.net/metalama/examples/notifypropertychanged).
+
+```c#
+using Metalama.Framework.Aspects;
+using Metalama.Framework.Code;
+using System.ComponentModel;
+
+namespace CommonTasks.NotifyPropertyChanged
+{
+    [Inheritable]
+    internal class NotifyPropertyChangedAttribute : TypeAspect
+    {
+        public override void BuildAspect(IAspectBuilder<INamedType> builder)
+        {
+            builder.Advice.ImplementInterface(builder.Target, typeof(INotifyPropertyChanged), OverrideStrategy.Ignore);
+
+            foreach (var property in builder.Target.Properties.Where(p =>
+                         !p.IsAbstract && p.Writeability == Writeability.All))
+            {
+                builder.Advice.OverrideAccessors(property, null, nameof(this.OverridePropertySetter));
+            }
+        }
+
+        [InterfaceMember]
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        [Introduce(WhenExists = OverrideStrategy.Ignore)]
+        protected void OnPropertyChanged(string name) =>
+            this.PropertyChanged?.Invoke(meta.This, new PropertyChangedEventArgs(name));
+
+        [Template]
+        private dynamic OverridePropertySetter(dynamic value)
+        {
+            if (value != meta.Target.Property.Value)
+            {
+                meta.Proceed();
+                this.OnPropertyChanged(meta.Target.Property.Name);
+            }
+
+            return value;
+        }
+    }
+}
+```
+
+<br>
+
+If you read through the code you should be able to see that it implements the INotifyPropertyChanged interface. Having done that it loops through the properties amending their setters where required to raise the the property changed event and finally it correctly implements the INotifyPropertyChanged interface. With the aspect added to your project The INotifyPropertyChanged implementation is made much simpler.
+
+<br>
+
+![](images/ct2.gif)
+
+<br>
+
+In what was an admittedly small and contrived sample class Metalama successfully implemented the INotifyPropertyChanged interface and in the process saved us having to add 50 additional lines of code. Over the entirety of a larger real world example the savings in writing repetitive boiler plate code will be considerable.
+
+<br>
+
+If you'd like to know more about Metalama in general then visit our [website](https://www.postsharp.net/metalama).
+
+Why not join us on [Slack](https://www.postsharp.net/slack) where you can keep up with what's new and get answers to any technical questions that you might have.

Markdown/CommonTasks/ct4.md

@@ -0,0 +1,79 @@
+# Common Tasks: Validating Code (Naming Conventions)
+
+One of the most difficult things to validate particularly for large teams but it can be equally applicable to smaller teams or even individuals working on an a large codebase are Naming conventions.
+
+Properly named methods can frequently convey intent or purpose just from their name so having rules in place to enforce this is not uncommon. The issue tends to be with how those rules are then enforced.-
+
+By way of an example imagine a situation where an application makes extensive use of stream readers and there are several classes created by different members of the team that implement said readers to perform various tasks. A decision has been taken to ensure that all such classes have the suffix 'StreamReader' added to their names so that it is clear what they do.
+
+Fabrics are a great way to enforce this type of validation, particularly ProjectFabric as they can cover an entire project.
+
+We'll create a Fabric that checks the codebase to ensure that the naming convention is being adhered to by the developers.
+
+<br>
+
+```c#
+using Metalama.Extensions.Architecture.Fabrics;
+using Metalama.Framework.Fabrics;
+
+
+    internal class NamingConvention : ProjectFabric
+    {
+
+
+        public override void AmendProject(IProjectAmender amender)
+        { amender.Verify().SelectTypesDerivedFrom(typeof(StreamReader)).MustRespectNamingConvention("*Reader"); }
+
+
+    }
+```
+
+<br>
+
+In the code above the fabric looks at each class in the project that is derived from `StreamReader`. If the name of any class that matches that criteria does not end in'Reader' then a warning is displayed.
+
+With our custom validation rule written let's put it to the test. In the code below we have two classes derived from StreamReader. One has the reader suffix the other does not and as such it should cause a warning to be displayed.
+
+<br>
+
+```c#
+namespace CommonTasks.NamingConventions
+{
+    internal class FancyStream : StreamReader
+    {
+
+
+        public FancyStream(Stream stream) : base(stream)
+        {
+        }
+
+
+    }
+
+
+    internal class SuperFancyStreamReader : StreamReader
+    {
+        public SuperFancyStreamReader(Stream stream) : base(stream)
+        {
+        }
+    }
+}
+```
+
+<br>
+
+We can see our warning in action below.
+
+<br>
+
+![](images/ct3.gif)
+
+<br>
+
+This is clearly a very simple example but it does illustrate how Metalama can be used to help validate your codebase and enforce rules. More information about this can be found in the [Metalama Documentation](https://doc.postsharp.net/metalama/conceptual/architecture/naming-conventions).
+
+<br>
+
+If you'd like to know more about Metalama in general then visit our [website](https://www.postsharp.net/metalama).
+
+Why not join us on [Slack](https://www.postsharp.net/slack) where you can keep up with what's new and get answers to any technical questions that you might have.

Markdown/CommonTasks/ct5.md

@@ -0,0 +1 @@
+# Common Tasks: