Added Samples for:

- Conditionals
- Anonymous Types
- Caller Info
- Extension Methods
- (Is) Null

Minor refactoring

Author: ahotko

CSharp Code Samples/CodeSamples/Attributes/ConditionalSample.cs

@@ -0,0 +1,52 @@
+#define CONDITION1
+#define CONDITION2
+
+using System;
+using System.Diagnostics;
+
+namespace CodeSamples.Attributes
+{
+    public class ConditionalSample : SampleExecute
+    {
+        [Conditional("CONDITION1")]
+        private void MethodCondition1()
+        {
+            Console.WriteLine("MethodCondition1");
+        }
+
+        [Conditional("CONDITION2")]
+        private void MethodCondition2()
+        {
+            Console.WriteLine("MethodCondition2");
+        }
+
+        [Conditional("CONDITION3")]
+        private void MethodCondition3()
+        {
+            Console.WriteLine("MethodCondition3");
+        }
+
+        [Conditional("CONDITION1"), Conditional("CONDITION2")]
+        private void MethodCondition1or2()
+        {
+            Console.WriteLine("MethodCondition1or2");
+        }
+
+        [Conditional("CONDITION1"), Conditional("CONDITION3")]
+        private void MethodCondition1or3()
+        {
+            Console.WriteLine("MethodCondition1or3");
+        }
+
+        public override void Execute()
+        {
+            Title("ConditionalSampleExecute");
+            MethodCondition1();
+            MethodCondition2();
+            MethodCondition3();
+            MethodCondition1or2();
+            MethodCondition1or3();
+            Finish();
+        }
+    }
+}

CSharp Code Samples/CodeSamples/Attributes/DebuggingSample.cs

@@ -19,19 +19,24 @@ public FullName(string firstName, string lastName)
         public string LastName { get; set; }
     }
 
+    /// <summary>
+    /// <para>
+    /// DebuggerBrowsableState.Collapsed - This signifies that the default behaviour should be used for the decorated member and 
+    ///      gives the equivalent results as when the attribute is omitted. When viewed in a debugging tool the member is visible 
+    ///      and can be expanded to allow access to any further members that it contains.
+    /// </para>
+    /// <para>
+    /// DebuggerBrowsableState.Never - This indicates that the member should not be displayed in debugging windows. The member is 
+    ///      hidden from view completely.
+    /// </para>
+    /// <para>
+    /// DebuggerBrowsableState.RootHidden - This signifies that the member should not be visible but that its own members should be. 
+    ///      The members of the hidden item appear as if they were one level higher in the hierarchy of values. This setting is useful 
+    ///      for members that are used only to store structured information, such as collection types or some data objects.
+    /// </para>
+    /// </summary>
     sealed class DebuggerExamplesDebuggerBrowsable
     {
-        /// <summary>
-        /// DebuggerBrowsableState.Collapsed - This signifies that the default behaviour should be used for the decorated member and 
-        ///      gives the equivalent results as when the attribute is omitted. When viewed in a debugging tool the member is visible 
-        ///      and can be expanded to allow access to any further members that it contains.
-        /// DebuggerBrowsableState.Never - This indicates that the member should not be displayed in debugging windows. The member is 
-        ///      hidden from view completely.
-        /// DebuggerBrowsableState.RootHidden - This signifies that the member should not be visible but that its own members should be. 
-        ///      The members of the hidden item appear as if they were one level higher in the hierarchy of values. This setting is useful 
-        ///      for members that are used only to store structured information, such as collection types or some data objects.
-        /// </summary>
-
         [DebuggerBrowsable(DebuggerBrowsableState.Collapsed)]
         public string StandardProperty { get; set; }
 
@@ -51,22 +56,28 @@ public int GetIntValue()
             return 5*2;
         }
 
+        /// <summary>
+        /// Also see <see cref="ConditionalSample"/> class
+        /// </summary>
         [Conditional("DEBUG")]
         public void ExecuteOnlyInDebugMode()
         {
-            Console.WriteLine($"Executed in DEBUG mode");
+            Console.WriteLine("Executed in DEBUG mode");
         }
 
+        /// <summary>
+        /// Also see <see cref="ConditionalSample"/> class
+        /// </summary>
         [Conditional("RELEASE")]
         public void ExecuteOnlyInReleaseMode()
         {
-            Console.WriteLine($"Executed in RELEASE mode");
+            Console.WriteLine("Executed in RELEASE mode");
         }
 
 #if DEBUG
         public void CompileOnlyWhenDebugDefined()
         {
-            Console.WriteLine($"Compiled and Executed in DEBUG mode");
+            Console.WriteLine("Compiled and Executed in DEBUG mode");
         }
 #endif
 

CSharp Code Samples/CodeSamples/Classes/AnonymousTypesSample.cs

@@ -0,0 +1,18 @@
+using System;
+
+namespace CodeSamples.Classes
+{
+    public class AnonymousTypesSample : SampleExecute
+    {
+        /// <summary>
+        /// Creates anonymous type (object) with properties Name, Lastname and Age
+        /// </summary>
+        public override void Execute()
+        {
+            Title("AnonymousTypesSampleExecute");
+            var anonymousObject = new { Name = "Foo", Lastname = "Bar", Age = 13 };
+            Console.WriteLine($"anonymousObject(), Name = {anonymousObject.Name}, Lastname = {anonymousObject.Lastname}, Age = {anonymousObject.Age}");
+            Finish();
+        }
+    }
+}

CSharp Code Samples/CodeSamples/Classes/CallerInfoSample.cs

@@ -0,0 +1,25 @@
+using System;
+
+namespace CodeSamples.Classes
+{
+    public class CallerInfoSample : SampleExecute
+    {
+        public void TraceMessage(string message, 
+            [System.Runtime.CompilerServices.CallerMemberName] string memberName = "",
+            [System.Runtime.CompilerServices.CallerFilePath] string sourceFilePath = "",
+            [System.Runtime.CompilerServices.CallerLineNumber] int sourceLineNumber = 0)
+        {
+            Console.WriteLine($"Message = {message}");
+            Console.WriteLine($"Member (Method) Name = {memberName}");
+            Console.WriteLine($"Source File Path = {sourceFilePath}");
+            Console.WriteLine($"Line Number = {sourceLineNumber}");
+        }
+
+        public override void Execute()
+        {
+            Title("CallerInfoSampleExecute");
+            TraceMessage("Tracing this call...");
+            Finish();
+        }
+    }
+}

CSharp Code Samples/CodeSamples/Classes/ExtensionMethodsSample.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Text;
+
+namespace CodeSamples.Classes
+{
+    public static class ExtensionMethods
+    {
+        public static string PadRightWithString(this string value, string padding, int paddingCount)
+        {
+            var result = new StringBuilder(value);
+            for (int i = 0; i < paddingCount; i++)
+            {
+                result.Append(padding);
+            }
+            return result.ToString();
+        }
+
+        public static void WriteToConsole(this string value)
+        {
+            Console.WriteLine($"Contents Of String = {value}");
+        }
+    }
+
+    public class ExtensionMethodsSample : SampleExecute
+    {
+        public override void Execute()
+        {
+            Title("ExtensionMethodsSampleExecute");
+            string testString = "test string";
+            string resultString = testString.PadRightWithString("<pad>", 5);
+            Console.WriteLine("Original string:");
+            testString.WriteToConsole();
+            Console.WriteLine("Padded string:");
+            resultString.WriteToConsole();
+            Finish();
+        }
+    }
+}

CSharp Code Samples/CodeSamples/CodeSamples.csproj

@@ -52,9 +52,13 @@
   <ItemGroup>
     <Compile Include="Alterations\EntityConversionSample.cs" />
     <Compile Include="Alterations\OperatorOverloadingSample.cs" />
+    <Compile Include="Attributes\ConditionalSample.cs" />
     <Compile Include="Attributes\ObsoleteSample.cs" />
+    <Compile Include="Classes\AnonymousTypesSample.cs" />
+    <Compile Include="Classes\CallerInfoSample.cs" />
     <Compile Include="Classes\ConstructorChainingSample.cs" />
     <Compile Include="Attributes\DebuggingSample.cs" />
+    <Compile Include="Classes\ExtensionMethodsSample.cs" />
     <Compile Include="ISampleExecute.cs" />
     <Compile Include="MultiThreading\BackgroundWorkerSample.cs" />
     <Compile Include="Patterns\Behavioral\ObserverPattern.cs" />
@@ -69,6 +73,7 @@
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="SampleExecute.cs" />
+    <Compile Include="SyntacticSugars\NullSample.cs" />
     <Compile Include="SyntacticSugars\PatternMatchingSample.cs" />
     <Compile Include="SyntacticSugars\PropertiesSample.cs" />
     <Compile Include="SyntacticSugars\StringInterpolationSample.cs" />

CSharp Code Samples/CodeSamples/Program.cs

@@ -39,52 +39,67 @@ static void Main(string[] args)
             var props = new PropertiesSample();
             props.Execute();
 
-            var usings = new UsingSample();
-            usings.Execute();
+            var Sample = new UsingSample();
+            Sample.Execute();
 
-            var interpol = new StringInterpolationSample();
-            interpol.Execute();
+            var stringInterpolation = new StringInterpolationSample();
+            stringInterpolation.Execute();
 
-            var patterns = new PatternMatchingSample();
-            patterns.Execute();
+            var patternMatchingSample = new PatternMatchingSample();
+            patternMatchingSample.Execute();
+
+            var nullSample = new NullSample();
+            nullSample.Execute();
             #endregion
 
             #region Useful
-            var useful = new ClassAndMethodNamesSample();
-            useful.Execute();
+            var classAndMethodNamesSample = new ClassAndMethodNamesSample();
+            classAndMethodNamesSample.Execute();
+
+            var callerInfo = new CallerInfoSample();
+            callerInfo.Execute();
             #endregion
 
             #region Patterns
-            var patts = new PatternsSample();
-            patts.Execute();
+            var patternsSample = new PatternsSample();
+            patternsSample.Execute();
             #endregion
 
             #region LINQ
-            var linqs = new LinqSample();
-            linqs.Execute();
+            var linqSample = new LinqSample();
+            linqSample.Execute();
             #endregion
 
             #region Operators
-            var opera = new OperatorOverloadingSample();
-            opera.Execute();
+            var operatorOverloadingSample = new OperatorOverloadingSample();
+            operatorOverloadingSample.Execute();
             #endregion
 
             #region Entity Conversion
-            var entityConv = new EntityConversionSample();
-            entityConv.Execute();
+            var entityConversionSample = new EntityConversionSample();
+            entityConversionSample.Execute();
             #endregion
 
             #region Classes
-            var consChain = new ConstructorChainingSample();
-            consChain.Execute();
+            var constructorChainingSample = new ConstructorChainingSample();
+            constructorChainingSample.Execute();
+
+            var anonymousTypesSample = new AnonymousTypesSample();
+            anonymousTypesSample.Execute();
+
+            var extensionMethodsSample = new ExtensionMethodsSample();
+            extensionMethodsSample.Execute();
             #endregion
 
             #region Attributes
             var debuggerAttributeSample = new DebuggingSample();
             debuggerAttributeSample.Execute();
 
-            var oboleteAttributeSample = new ObsoleteSample();
-            oboleteAttributeSample.Execute();
+            var obsoleteAttributeSample = new ObsoleteSample();
+            obsoleteAttributeSample.Execute();
+
+            var conditionalAttributeSample = new ConditionalSample();
+            conditionalAttributeSample.Execute();
             #endregion
 
             #region Threading

CSharp Code Samples/CodeSamples/SyntacticSugars/NullSample.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace CodeSamples.SyntacticSugars
+{
+    public class NullSample : SampleExecute
+    {
+        public override void Execute()
+        {
+            Title("NullSampleExecute");
+
+            Object obj = null;
+
+            if(obj is null)
+            {
+                Console.WriteLine("Object is null.");
+            }
+
+            if (obj is object)
+            {
+                Console.WriteLine("Object is not null.");
+            }
+
+            Finish();
+        }
+    }
+}