<h4>Understand the difference between two GrainCollectionOptions, and how they are used in the GarbageCollection process.</h4>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*t9hh6KKN9oFVsX_g"><figcaption>Photo by <a href="https://unsplash.com/@neonbrand?utm_source=medium&amp;utm_medium=referral">Kenny Eliason</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><blockquote>You probably landed on this article, after finding the definition of both terms a tad blurry. I did find them blurry initially before pondering on the terms, their definitions and the results I got after I tinkered with them a bit. Here’s what I found.</blockquote>
<h3>What is CollectionAge</h3>
<a href="https://docs.microsoft.com/en-us/dotnet/api/orleans.configuration.graincollectionoptions.collectionage?view=orleans-3.0">CollectionAge</a> is used to dictate how long a Grain can be inactive for, before it gets collected for deactivation, by Orleans’ GarbageCollection. Think of this as an idle timeout.
<h3>What is CollectionQuantum</h3>
<a href="https://docs.microsoft.com/en-us/dotnet/api/orleans.configuration.graincollectionoptions.collectionquantum?view=orleans-3.0">CollectionQuantum</a> is used internally by Orleans to regulate the interval at which it does a collection sweep. Consider this a pulse.
<h3>Difference Between CollectionAge and CollectionQuantum</h3>
<ol>
<li>CollectionAge helps us track whether or not a Grain can be considered inactive. CollectionQuantum is the interval which regulates Orleans' collection of inactive Grains.</li>
<li>CollectionQuantum being a pulse interval, always has to be smaller than CollectionAge.</li>
<li>CollectionQuantum is used internally by Orleans hence it cannot be set on a Grain level. CollectionAge can be set specifically for different Grains (<a href="https://docs.microsoft.com/en-us/dotnet/api/orleans.configuration.graincollectionoptions.classspecificcollectionage?view=orleans-3.0">check </a><a href="https://docs.microsoft.com/en-us/dotnet/api/orleans.configuration.graincollectionoptions.classspecificcollectionage?view=orleans-3.0">ClassSpecificCollectionAge</a>)</li>
<li>CollectionQuantum defaults to 1 minute. In contrast, CollectionAge defaults to 30 minutes.</li>
</ol>
The CollectionAge works as an idle timeout for the Grain, while CollectionQuantum works as a pulse for Orleans to collect all Grains that have been idle longer than their CollectionAge
<h3>How Do CollectionAge and CollectionQuantum Work Together</h3>
Imagine you have a Grain class which has a CollectionAge of 10 minutes. This class also only sends/receives a message once every 20 minutes.
If the CollectionQuantum is configured to 1 minute, every minute, Orleans will do a check for all the Grains that have expired (ie. have not sent/received any data for at least 10 minutes). In this case, our grain will get deactivated after the 10th minute.
If this helped get a grasp of the difference between CollectionAge and CollectionQuantum, please clap, share and subscribe.
<a href="https://tomisin.dev/subscribe">Subscribe * Tomisin Abiodun</a>
Till next time, buddy!
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=e23e4283ec97" width="1" height="1" alt="">

Understand the difference between two GrainCollectionOptions, and how they are used in the GarbageCollection process.

Orleans: CollectionAge vs CollectionQuantum

<h4>A dive into Reflection in .NET — learning some of it’s popular use-cases.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*PLjHppYR0SAWhO2d" /><figcaption>Photo by <a href="https://unsplash.com/@arvind_jay_v?utm_source=medium&amp;utm_medium=referral">Aravind V</a> on <a href="https://unsplash.com?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Objectives</h3>After reading this article, readers should be able to<ol><li>Define what Reflection is and know what it can be used for.</li><li>Know the difference between System.Type objects and type(s).</li><li>Comfortably use Reflection to get the Type of an object or a type.</li><li>Understand how to interact withType objects.</li><li>Use Reflection to access custom Attributes.</li></ol><h3>What is Reflection</h3>First, let’s get the obvious question out of the way.Reflection is the process by which we can get System.Type instances — which can then be used to describe assemblies, types and modules or even invoke methods and access variables of their target objects. Reflection also allows us to access the Attributes of our objects and their data.Straight away, we see that where we are using Reflection, we would also need the System.Type, so we need to add the following lines to the top of our .cs file.<pre>using System; using System.Reflection;</pre><h3>Difference between System.Type and type</h3>Before we move forward, it is important to be clear on what System.Type is, and how it differs from type.To paraphrase <a href="https://docs.microsoft.com/en-us/dotnet/csharp/fundamentals/types/">the official documentation on C# types</a>, each variable or constant in C# has a type (string, int, float, etc). Each method also takes in and returns parameters and values of known type. There are several categories of the type; ranging from <a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/built-in-types">builtin types</a> (ex. string, long, bool), to <a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/value-types">value types</a> (ex. struct and enum) and <a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/reference-types">reference types</a> (ex. class, interface, delegate and record).System.Type on the other hand, provides us with methods through which we can reflect on objects, variables and constants, regardless of their type.<h3>Getting the System.Type</h3>There are two ways we can get the System.Type object, depending on whether we are getting that of a type or an object.<h4>Getting System.Type from an object</h4>In order to get the System.Type instance of an object, we use the GetType() method of the object.<pre>namespace MyProject; public class Example { public static void Main(string[] args) { Example example = new(); Type exampleType = example.GetType(); Console.WriteLine(exampleType); // MyProject.Example } }</pre>We can also use it to retrieve the System.Type instance, when the type is to be inferred at compile time (variables of type var).<pre>var a = 10; Console.WriteLine(a.GetType()); // System.Int32</pre><h4>Getting System.Type from a type</h4>Alternatively, if we wish to get the System.Type instance of a type, we use typeof.<pre>namespace MyProject; public class Example { public static void Main(string[] args) { Type exampleType = typeof(Example); Console.WriteLine(exampleType); // MyProject.Example } }</pre><h4>Differences between GetType and typeof</h4>We have seen two different ways of obtaining the System.Type instance of objects and types respectively. Let’s take a deeper look at the contrast between the two approaches.<ol><li>.GetType() is done at run time, while typeof is done at compile time.</li><li>.GetType() is only used to get the System.Type of an object instance, while typeof retrieves the System.Type of a type.</li></ol><h3>Common Use Cases of Reflection</h3>At this stage, we are comfortable using Reflection to retrieve the System.Type instance of objects and types. Now we are going to explore and learn about the ways we can use System.Type and what we can achieve with Reflection.Some of the more common use cases of Reflection include<h4>Getting Assembly information</h4>One of the most common use cases of Reflection in C# is actually getting the assembly of a particular instance.<pre>Console.WriteLine(typeof(int).Assembly); // System.Private.CoreLib, Version=6.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e</pre><h4>Knowing an object’s actual Type</h4>Sometimes in development, we use object-typed variables so that we have more generic and dynamic variables to work. However, this often comes at the cost of being able to access the methods, variables and properties.<pre>namespace MyProject; public class Human { public Human(string name) { Name = name; } public string Name { get; } public void SayHello() { Console.WriteLine($&quot;Hello, I am {Name}! Nice to meet you.&quot;); } } public class Example { public static void Main(string[] args) { object alex = new Human(&quot;Alex&quot;); Console.WriteLine(alex.Name); } }</pre>This would give use the following error at compile time:<figure><img alt="" src="https://cdn-images-1.medium.com/max/1007/1*X-eGFhEkPqlOSOpUUwXVuw.png" /></figure>We can take the easy way out of casting the object-typed variable into the type we wish to interact with.Alternatively, using Reflection, we can retrieve the System.Type and then interact with that more easily and fluently.<pre>public class Example { public static void Main(string[] args) { object alex = new Human(&quot;Alex&quot;); Type alexType = alex.GetType(); // Get the property and method info from the Type PropertyInfo alexNameProp = alexType.GetProperty(&quot;Name&quot;); MethodInfo methodInfoProp = alexType.GetMethod(&quot;SayHello&quot;); // Retrieve the value or invoke the method on an instance Console.WriteLine($&quot;From {alexNameProp?.GetValue(alex)}&quot;); methodInfoProp?.Invoke(alex, new object[] { }); } }</pre>Looking at the example above, you would notice that after we retrieved the PropertyInfo alexNameProp and the MethodInfo methodInfoProp, we needed to pass a reference of the instance from which the Type was obtained (ie. alex). This stems from the fact we have walked up the hierarchy, from the instance alex up to its classType, hence the need for an instance on which to act upon.<h4>Getting the Type Arguments supplied to an object</h4>Consider a simple Dictionary mapping string to int<pre>Dictionary&lt;string, int&gt; nameAgeMap = new() { { &quot;Ade&quot;, 10 } }; Type nameAgeMapType = nameAgeMap.GetType();</pre>We can use the method GetGenericArguments to get the types arguments supplied to the Dictionary declaration.<pre>Type[] typeArgs = nameAgeMapType.GetGenericArguments(); foreach (Type tParam in typeArgs) { Console.WriteLine($&quot;Type Argument: {tParam}&quot;); } // Type Argument: System.String // Type Argument: System.Int32</pre><h4>Retrieving data from Attributes using Reflection</h4>We can obtain the data stored in Attributes by using the Reflection method GetCustomAttribute found in System.Type. Take for example, we have a custom Attribute called Nationality .<pre>public class NationalityAttribute : Attribute { public string country; public NationalityAttribute(string country) { this.country = country; } }</pre>Which we want to use on our Human class, for the sake of clarity, let’s define it again below.<pre>public class Human { public Human(string name) { Name = name; } public string Name { get; } }</pre>We could use Reflection to get the data from the Attribute called Nationality just like in the method SayHello below.<pre>[Nationality(&quot;Australia&quot;)] public class Human { ... public void SayHello() { Type thisType = this.GetType(); Attribute _attr = thisType.GetCustomAttribute( typeof(NationalityAttribute)); NationalityAttribute natAttr_ = (NationalityAttribute)_attr; Console.WriteLine($&quot;Hello, my name is {Name}! I come from {natAttr_?.country}&quot;); } }</pre>The first thing we did in the example above, is to get the System.Type value of the Human object. Next, we used Reflection to get the attribute of type NationalityAttribute attached to it. It’s important to note that the GetCustomAttribute method returns a value of type Attribute and not the type passed to it as an argument. Finally, we casted the value of type Attribute into NationalityAttribute and we are able to interact with the attribute.We could also access all Attributes of an object by invoking the GetCustomAttributes method of the Attribute class on a Type.<pre>Type humanType = typeof(Human); foreach (Attribute attr in Attribute.GetCustomAttributes(humanType)) { Console.WriteLine($&quot;Attribute {attr}&quot;); }</pre><h3>Summary</h3>Reflection is not something talked about a lot in .NET, though it could be really useful and applicable in so many different ways — few of which we explored in this article.If you found this article, clap, share and subscribe.<a href="https://tomisin.dev/subscribe">Subscribe * Tomisin Abiodun</a>Till next time!<img alt="" height="1" src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=56ba1d3d1f22" width="1" />

A dive into Reflection in .NET — learning some of it’s popular use-cases.

Understanding Reflection in .NET within 5 minutes.

<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*7PLF5_fdmmyDnaEU" /><figcaption>Photo by <a href="https://unsplash.com/@efekurnaz?utm_source=medium&amp;utm_medium=referral">Efe Kurnaz</a> on <a href="https://unsplash.com?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure>It could be confusing to differentiate between the two major delegate types in C# — Func and Action, due to their similar syntax and parent type. While both delegate types could receive arrow functions or method group values, the difference lies in what they are expected (or not expected) to return. Func methods are expected to return a value while Action methods are expected to be void.In this article, we would explore the differences between the two delegate types as well as appropriate use-cases.To understand the two types, we need to first understand what a delegate is and how it is intended to be used.<h3>What are Delegates in C#</h3>Delegates (simply put) help us assign methods to variables. As such, a delegate could be used to pass a method as a parameter to other methods.For the sake of <a href="https://www.freecodecamp.org/news/orthogonality-in-software-engineering/#:~:text=Orthogonality%20is%20a%20software%20design,a%20term%20borrowed%20from%20mathematics.">orthogonality</a>, we sometimes have the need to pass a method, based on some criteria to an executing method to invoke — and that’s where delegates come in.Delegates can be declared at namespace-level. They are also used for callbacks. It is also possible to have either arrow functions or class methods assigned to a delegate. There is also support for chaining delegate callbacks, provided they have the same signatures.Declaring a delegate is similar to declaring a class in C#. Take this for example.<pre>public class DelegateExample { public delegate string Greet(); public DelegateExample() { Greet greet = this.SayHelloWorld; greet(); } private string SayHelloWorld() { return &quot;Hello world&quot;; } }</pre><h3>Func in C#</h3>The last type parameter in a Func declaration is the type of the output value. As we know, a Func must return a value. So, we must always have at least one type parameter.Let’s see a simple example of a Func in C#.<pre>public class FuncExampleOne { Func&lt;string&gt; Greet; public FuncExampleOne() { Greet = this.GreetUserInEnglish; Greet(); } public string GreetUserInEnglish() { return &quot;Hello! How are do you today&quot;; } }</pre>In the example above, we have a method GreetUserInEnglish which returns a string. We then assign it to a Func&lt;string&gt; variable, which we later invoke right before exiting the constructor.Let’s take another example of a Func, taking a number parameter and returning a string output.<pre>public class FuncExampleTwo { Func&lt;int, string&gt; SayTemperature; public FuncExampleTwo() { SayTemperature = this.GiveTemperatureSummary; Console.WriteLine(SayTemperature(30)); } public string GiveTemperatureSummary(int temp) { return $&quot;It's {temp} degrees outside.&quot;; } }</pre>A Func variable could also be an arrow function and we could pass a Func variable as a parameter to other methods, as we see the example below.<pre>public class FuncExampleThree { public FuncExampleThree() { Func&lt;int, string&gt; GetFriendlyTemp = (int temp) =&gt; { return $&quot;It's {temp} degrees outside.&quot;; }; DisplayTempText(GetFriendlyTemp); // It's 30 degrees outside. } public void DisplayTempText(Func&lt;int, string&gt; getFriendlyTemp) { Console.WriteLine(getFriendlyTemp()); } }</pre><h3>Action in C#</h3>Most of the convention of Func variables also apply to Action. The major difference being that an Action does not return anything. As such, all the type parameters of any Action declaration are of input parameters. In the case where the Action does not accept any parameter, no type parameter is required.For example, this would be a valid Action declaration in C#.<pre>public class ActionExampleOne { Action Greet; public DelegateExample() { Greet = this.SayHelloWorld; Greet(); } public void SayHelloWorld() { Console.WriteLine(&quot;Hello world!&quot;); } }</pre>From the signature of an Action, we can tell that they’ll be perfect for callbacks.Another feature unique to Action variables, is the ability to chain them. We could chain Action variables, so long as they have the same signatures. In this case, the methods will be invoked in the order they were chained.<pre>public class ActionChainExample { public ActionChainExample() { Action&lt;int&gt; GetFriendlyTemp = (int _) =&gt; { }; GetFriendlyTemp += (int temp) =&gt; { Console.Write($&quot;It's {temp} degrees outside.&quot;); }; GetFriendlyTemp += (int temp) =&gt; { string _season = temp &lt; 40 ? &quot;winter&quot; : &quot;summer&quot;; Console.Write($&quot; We are in {_season} season!&quot;); }; GetFriendlyTemp(45); // It's 45 degrees outside. We are in summer season! } }</pre><h3>Conclusion</h3>When having to choose between both delegate types, ask yourself the following questionsWhat does this method return? If it returns nothing, use an Action. If you have an async method or a method that returns anything, use a Func.Would I have a need to chain this method? If you would have a need to chain this method, an Action would work better than a Func.Thanks for reading! If you found the article helpful, clap, share and subscribe.<img alt="" height="1" src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=82e4b1965d13" width="1" />

Learn the difference between two major delegate types in C# — Func and Action.

distributed-systems

Orleans: CollectionAge vs CollectionQuantum

c-sharp-programming

Understanding Reflection in .NET within 5 minutes.

Get one coding trick and an article delivered every week at no extra cost

c-sharp-programming

C# Delegates: Difference between Func and Action