Category: .NET

AppContext is like Application in ASP.NET (MVC). You can see the value all over the application

AppContext.SetSwitch("OCR", true);

And we can have the result in all dll’s by

 public bool IsOCREnabled()
        {
            bool test;
            if (!AppContext.TryGetSwitch("OCR", out test))
                return false;

            return test;
        }

Video demo at https://youtu.be/GMgn4o3yPqw

For many programmers a try/catch with stack trace it is enough

try
{
var p = new Person();
p.DateOfBirth = DateTime.Now.AddYears(-10);
p.Drink(10, 2);
}
catch (Exception ex)
{
Console.WriteLine("ERROR OCCURED " + ex.StackTrace);
}

Others want to see also functions arguments, like in

p.Drink(10, 2);

will produce the result

ERROR An exception occured in method InstrumentationPostSharp.Person.Drink with (beersNumber = 10 , vodkaNumber = 2)

For this you can install the package
https://www.nuget.org/packages/LoggerAspect.Nlog

that have full source code at
https://github.com/vnvizitiu/AOP/tree/master/PostSharpTutorial

and watch my video for more details
https://youtu.be/qe2kpuuWXkw

When you intercept exceptions( for logging ) you can

 
catch (Exception ex)
            {
                //TODO: log : 
                //https://youtu.be/OvzcBTm3Sow
                string s = ex.Message;
                throw ex;
            }
 

or

 
catch (Exception ex)
            {
                //TODO: log : 
                //https://youtu.be/OvzcBTm3Sow
                string s = ex.Message;
                throw ;
            }

The difference is small – but the consequences are losing the original stack trace , if you

 throw ex; 

I have done a small video about this : https://youtu.be/Deigld3Bqko

I have not covered ExceptionDispatchInfo  that you can see an usage here: http://blogs.microsoft.co.il/sasha/2011/10/19/capture-transfer-and-rethrow-exceptions-with-exceptiondispatchinfo-net-45/

For me , I like

 [DebuggerDisplay("FirstName={FirstName}, LastName={LastName}")] 

and

[DebuggerStepThrough] 

The code is the following:

 class Program { static void Main(string[] args) { var p = new Person(); p.FirstName = "Andrei"; p.LastName = "Ignat"; Console.WriteLine(p.Name()); //InternalsVisibleToAttribute //Obsolete //All Attributes: https://msdn.microsoft.com/en-us/library/system.attribute.aspx } } [DebuggerDisplay("FirstName={FirstName}, LastName={LastName}")] class Person { public string FirstName { get; set; } public string LastName { get; set; } [DebuggerStepThrough] public string Name() { return FirstName + " " + LastName; } } 

and the video is at https://youtu.be/ShBr1GgpZKs

For validating a simple class, you can add [Required] ( see https://msdn.microsoft.com/en-us/library/ee256141(v=vs.100).aspx

But how to validate same object depending on his state? For example, when it is new, the email is required. But after saving, the user mus also add FirstName( also think about workflows)

There is a simple solution in .NET : IValidatableObject
In this example , I validate differently based on the object is new or retrieved from database:

 internal class Person:IValidatableObject
    {
        public int id { get; set; }
      
        public string Email { get; set; }

        public string FirstName { get; set; }

        /// <summary>
        /// MVC and EF are calling this if the class implements  IValidatableObject
        /// </summary>
        /// <param name="validationContext"></param>
        /// <returns></returns>
        public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
        {

            if (string.IsNullOrWhiteSpace(Email))
            {
                yield return new ValidationResult("my Email is required");
            }
            if (id == 0) //new
            {
                yield break;
            }

            //existing
            if(string.IsNullOrWhiteSpace(FirstName))
            {
                yield return new ValidationResult("First name is required");
            }

        }
    }

If you want to see in action , please see https://youtu.be/rjj0jjj3rxM

Please read the code and answer question below:

class Program
    {
        static void Main(string[] args)
        {


            IEnumerable<int> myEnum = Data().Where(it => it < 5);

            string site = "http://msprogrammer.serviciipeweb.ro/";

            int[] arr = myEnum.ToArray();

            site +=" number is "+ myEnum.Count();
            site += " number is " + myEnum.Count();
            Console.WriteLine(site);

        }


        static IEnumerable<int> Data()
        {

            int i = 5;
            i++;

            yield return i;
            yield return (i+7);
        }
    }

How many times the breakpoint at

int i = 5;

will be hit ?

Why?

And if your answer is not 3, please look at https://youtu.be/1fy_T9TCPpc

    /// <summary>
    /// please read first http://blog.stephencleary.com/2012/02/async-and-await.html
    /// </summary>

Let’s say you want to transform this code to async / await

public bool TwoTask()
        {
            var file= WriteToFile();
            var console= ReadConsole();
            return file & console;
        }

The first version is

public async Task<bool> TwoTask()
        {
            var file=await WriteToFile();
            var console = await ReadConsole();
            return file & console;
        }

Why is not good ? Because it executes in serial the file, and then the console code

The good version is

public async Task<bool> TwoTask()
        {
            var file=WriteToFile();
            var console = ReadConsole();
            await Task.WhenAll(file, console);
            return file.Result & console.Result;
        }

You can see in action at https://youtu.be/02oO0YaTEyM