Dot Net Deewane

What are 'closures' in .NET?

2022-01-25T08:26:00.006-08:00

In essence, a closure is a block of code that can be executed at a later time, but which maintains the environment in which it was first created - i.e. it can still use the local variables, etc of the method which created it, even after that method has finished executing.

The general feature of closures is implemented in C# by anonymous methods and lambda expressions.

Here's an example using an anonymous method:

using System;

class Test
{
   static void Main()
   {
       Action action = CreateAction();
       action();
       action();
   }

   static Action CreateAction()
   {
       int counter = 0;
       return delegate
       {
           // Yes, it could be done in one statement;
           // but it is clearer like this.
           counter++;
           Console.WriteLine("counter={0}", counter);
       };
   }
}

Output:
counter=1
counter=2

Here we can see that the action returned by CreateAction still has access to the counter variable, and can indeed increment it, even though CreateAction itself has finished.

Basics of Kubernetes

2021-11-21T06:40:00.007-08:00

Kubernetes is an open-source container orchestration framework, it was developed by Google. Kubernetes manages containers it could be a docker container or any other container technology. So we can say that Kubernetes help us manage the containerized application, We can use Kubernetes on a different type of environments let it be a physical server, virtual machines or cloud.

What Problem Does It Solve: The rise of microservice architecture has increased the use of container technologies. nowadays a complex enterprise application can have thousands of containers. managing those containers using scripts or self-made tools is very tough and error-prone. Kubernetes like container orchestration tools solve this problem.

A container orchestration tool offers the following features

High Availability or no downtime
Scalability or high performance
Disaster recovery

Basic Architectures: Kubernetes cluster is made of at least one master node and connected to it a couple of worker nodes. These worker nodes have a process running on them which is known as kubelet (primary node agent). kubelet makes it possible for these worker nodes to talk to each other, also it executes tasks needed to keep the cluster running. these worker nodes can have one of the multiple containers running on them.

Master nodes run several important Kubernetes processes which are necessary to run and manage Kubernetes clusters properly, one of the processes is the API server, it's a container that is an entry point for the K8S cluster. If you are using UI, API, or CLI to manage the cluster it interacts with this API service. Another Important service running on master is controller manager, it keeps a track of what is happening in the cluster. whether something needs to be repaired or a container died and needs to be restarted. Another important service is scheduled, it's responsible for the creation of the pods on the nodes, scheduler keeps track of the resources on different worker nodes, and based on the need it decides on which nodes the next pod should be created. Another important component of the Kubernetes cluster that runs on the master nodes is etcd storage, its key-value pair which stores the current state of the cluster. it users to restore the cluster based on the need.

Another important part of Kubernetes is the virtual network, which converts the whole cluster into a single unified powerful machine.

We can see that the actual application will be deployed on worker nodes, which means most of the work will be done by worker nodes, and due to that, these worker nodes will be the bigger machine. where master nodes just run a handful of services, but the master is very important for the proper functioning of the whole cluster so if the master is down we will not be able to access the cluster due to that there could be multiple master nodes as in production environment so that when one master node is done cluster can still work smoothly as we have other master nodes available.

Basic Concepts: let us understand a few basic but important Kubernetes concepts, pods, and containers. The pod is the smallest unit which as a Kubernetes user you will/can configure. The pod is a wrapper on the container. in a pod, you can have one or more containers. Usually, per application, you will have one pod, for example, the database could need one pod, UI could need another Pod, API could need another Pod, So if your application needs only one container then the Pod will have a single container in it. or if the application needs multiple containers then Pod will have multiple containers.

Each pod is a self-contained server with its own IP address. the way they communicate with each other with the help of these IPs. We do not configure or create containers directly in the Kubernetes cluster. We work with Pods. Pod manages the container running inside itself. So if a container dies within a Pod then Pod restarts that container automatically. Pods are themselves ephemeral components that mean pods can also die very frequently and when a pod dies a new one gets created, here is where the notion of services comes into play so when a pod gets restarted or recreated a new pod is created with a new IP address, so if you were running a database on a Pod and using that Pod's IP address to connect to this database if the pod restarted the IP will change and other pods where the applications are deployed will not be able to connect to that database. This is very inconvenient to use the IP address to access the Pod. This is where another component of Kubernetes called service is used, which is basically and substitute for those IPs. Service is basically a component seat in front of each Pod that talks to each other. so if a Pod behind the service dies and gets recreated the service stays in place. as the service life cycle is not tied to Pod.

Service has to main functionality one is IP address means it has a permanent IP address which can be used to communicate between the pods and at the same time its a load balancer

Example Configurations: Let us now see how we can configure different Kubernetes components. All the configurations in the Kubernetes go through the master node with the process called API server. Kubernetes client which could be UI (Kubernetes dashboard) or an API which could be a script or CLI, all talk to API server and they send their configuration request to the API server in the form of JSON or XAML format, In the request, we send a deployment which is nothing but a template to create a Pod.

in the example above we are asking Kubernetes to create two pods with the app name my-app which will be based on the containers images my-images. also, we are passing the environment variable.

This configuration is declarative in nature and using these configurations we are telling Kubernetes that what is the desired state. So Kubernetes master controller component checks that state of the cluster and if it does not match with the configuration then creates the pods to meet the desired state.

The 10 Most Common Mistakes That C# Developers Make

2018-07-29T08:16:00.003-07:00

C# is an object oriented, strongly-typed language. The strict type checking in C#, both at compile and run times, results in the majority of typical programming errors being reported as early as possible, and their locations pinpointed quite accurately. This can save the C# programmer a lot of time, compared to tracking down the cause of puzzling errors which can occur long after the offending operation takes place in languages which are more liberal with their enforcement of type safety. However, a lot of programmers unwittingly (or carelessly) throw away the benefits of this detection, which leads to some of the issues discussed in this post.

Common Mistake #1: Using a reference like a value or vice versa

Programmers of C++, and many other languages, are accustomed to being in control of whether the values they assign to variables are simply values or are references to existing objects. In C#, however, that decision is made by the programmer who wrote the object, not by the programmer who instantiates the object and assigns it to a variable. This is a common “gotcha” for newbie C# programmers.

If you don’t know whether the object you’re using is a value type or reference type, you could run into some surprises. For example:

 Point point1 = new Point(20, 30);
  Point point2 = point1;
  point2.X = 50;
  Console.WriteLine(point1.X);       // 20 (does this surprise you?)
  Console.WriteLine(point2.X);       // 50
  
  Pen pen1 = new Pen(Color.Black);
  Pen pen2 = pen1;
  pen2.Color = Color.Blue;
  Console.WriteLine(pen1.Color);     // Blue (or does this surprise you?)
  Console.WriteLine(pen2.Color);     // Blue

As you can see, both the Point and Pen objects were created the exact same way, but the value of point1 remained unchanged when a new X coordinate value was assigned to point2, whereas the value of pen1 was modified when a new color was assigned to pen2. We can therefore deduce that point1 and point2 each contain their own copy of a Point object, whereas pen1 and pen2 contain references to the same Pen object. But how can we know that without doing this experiment?

The answer is to look at the definitions of the object types (which you can easily do in Visual Studio by placing your cursor over the name of the object type and pressing F12):

  public struct Point { … }     // defines a “value” type
  public class Pen { … }        // defines a “reference” type

As shown above, in C#, the struct keyword is used to define a value type, while the class keyword is used to define a reference type. For those with a C++ background, who were lulled into a false sense of security by the many similarities between C++ and C# keywords, this behavior likely comes as a surprise that may have you asking for help from a C# tutorial.

If you’re going to depend on some behavior which differs between value and reference types – such as the ability to pass an object as a method parameter and have that method change the state of the object – make sure that you’re dealing with the correct type of object to avoid C# problems.

Common Mistake #2: Misunderstanding default values for uninitialized variables

In C#, value types can’t be null. By definition, value types have a value, and even uninitialized variables of value types must have a value. This is called the default value for that type. This leads to the following, usually unexpected result when checking if a variable is uninitialized:

  class Program {
      static Point point1;
      static Pen pen1;
      static void Main(string[] args) {
          Console.WriteLine(pen1 == null);      // True
          Console.WriteLine(point1 == null);    // False (huh?)
      }
  }

Why isn’t point1 null? The answer is that Point is a value type, and the default value for a Point is (0,0), not null. Failure to recognize this is a very easy (and common) mistake to make in C#.

Many (but not all) value types have an IsEmpty property which you can check to see if it is equal to its default value:

  Console.WriteLine(point1.IsEmpty);        // True

When you’re checking to see if a variable has been initialized or not, make sure you know what value an uninitialized variable of that type will have by default and don’t rely on it being null..

Common Mistake #3: Using improper or unspecified string comparison methods

There are many different ways to compare strings in C#.

Although many programmers use the == operator for string comparison, it is actually one of the leastdesirable methods to employ, primarily because it doesn’t specify explicitly in the code which type of comparison is wanted.

Rather, the preferred way to test for string equality in C# is with the Equals method:

  public bool Equals(string value);
  public bool Equals(string value, StringComparison comparisonType);

The first method signature (i.e., without the comparisonType parameter), is actually the same as using the == operator, but has the benefit of being explicitly applied to strings. It performs an ordinal comparison of the strings, which is basically a byte-by-byte comparison. In many cases this is exactly the type of comparison you want, especially when comparing strings whose values are set programmatically, such as file names, environment variables, attributes, etc. In these cases, as long as an ordinal comparison is indeed the correct type of comparison for that situation, the only downside to using the Equals method without a comparisonType is that somebody reading the code may not know what type of comparison you’re making.

Using the Equals method signature that includes a comparisonType every time you compare strings, though, will not only make your code clearer, it will make you explicitly think about which type of comparison you need to make. This is a worthwhile thing to do, because even if English may not provide a whole lot of differences between ordinal and culture-sensitive comparisons, other languages provide plenty, and ignoring the possibility of other languages is opening yourself up to a lot of potential for errors down the road. For example:

  string s = "strasse";
  
  // outputs False:
  Console.WriteLine(s == "straße");
  Console.WriteLine(s.Equals("straße"));
  Console.WriteLine(s.Equals("straße", StringComparison.Ordinal));
  Console.WriteLine(s.Equals("Straße", StringComparison.CurrentCulture));        
  Console.WriteLine(s.Equals("straße", StringComparison.OrdinalIgnoreCase));
  
  // outputs True:
  Console.WriteLine(s.Equals("straße", StringComparison.CurrentCulture));
  Console.WriteLine(s.Equals("Straße", StringComparison.CurrentCultureIgnoreCase));

The safest practice is to always provide a comparisonType parameter to the Equals method. Here are some basic guidelines:

When comparing strings that were input by the user, or are to be displayed to the user, use a culture-sensitive comparison (CurrentCulture or CurrentCultureIgnoreCase).
When comparing programmatic strings, use ordinal comparison (Ordinal or OrdinalIgnoreCase).
InvariantCulture and InvariantCultureIgnoreCase are generally not to be used except in very limited circumstances, because ordinal comparisons are more efficient. If a culture-aware comparison is necessary, it should usually be performed against the current culture or another specific culture.

In addition to the Equals method, strings also provide the Compare method, which gives you information about the relative order of strings instead of just a test for equality. This method is preferable to the <, <=, > and >= operators, for the same reasons as discussed above–to avoid C# problems.

Common Mistake #4: Using iterative (instead of declarative) statements to manipulate collections

In C# 3.0, the addition of Language-Integrated Query (LINQ) to the language changed forever the way collections are queried and manipulated. Since then, if you’re using iterative statements to manipulate collections, you didn’t use LINQ when you probably should have.

Some C# programmers don’t even know of LINQ’s existence, but fortunately that number is becoming increasingly small. Many still think, though, that because of the similarity between LINQ keywords and SQL statements, its only use is in code that queries databases.

While database querying is a very prevalent use of LINQ statements, they actually work over any enumerable collection (i.e., any object that implements the IEnumerable interface). So for example, if you had an array of Accounts, instead of writing:

  decimal total = 0;
  foreach (Account account in myAccounts) {
    if (account.Status == "active") {
      total += account.Balance;
    }
  }

you could just write:

  decimal total = (from account in myAccounts
                   where account.Status == "active"
                   select account.Balance).Sum();

While this is a pretty simple example of how to avoid this common C# programming problem, there are cases where a single LINQ statement can easily replace dozens of statements in an iterative loop (or nested loops) in your code. And less code general means less opportunities for bugs to be introduced. Keep in mind, however, there may be a trade-off in terms of performance. In performance-critical scenarios, especially where your iterative code is able to make assumptions about your collection that LINQ cannot, be sure to do a performance comparison between the two methods.

Common Mistake #5: Failing to consider the underlying objects in a LINQ statement

LINQ is great for abstracting the task of manipulating collections, whether they are in-memory objects, database tables, or XML documents. In a perfect world, you wouldn’t need to know what the underlying objects are. But the error here is assuming we live in a perfect world. In fact, identical LINQ statements can return different results when executed on the exact same data, if that data happens to be in a different format.

For instance, consider the following statement:

  decimal total = (from account in myAccounts
                   where account.Status == "active"
                   select account.Balance).Sum();

What happens if one of the object’s account.Status equals “Active” (note the capital A)? Well, if myAccounts was a DbSet object (that was set up with the default case-insensitive configuration), the where expression would still match that element. However, if myAccounts was in an in-memory array, it would not match, and would therefore yield a different result for total.

But wait a minute. When we talked about string comparison earlier, we saw that the == operator performed an ordinal comparison of strings. So why in this case is the == operator performing a case-insensitive comparison?

The answer is that when the underlying objects in a LINQ statement are references to SQL table data (as is the case with the Entity Framework DbSet object in this example), the statement is converted into a T-SQL statement. Operators then follow T-SQL rules, not C# rules, so the comparison in the above case ends up being case insensitive.

In general, even though LINQ is a helpful and consistent way to query collections of objects, in reality you still need to know whether or not your statement will be translated to something other than C# under the hood to ensure that the behavior of your code will be as expected at runtime.

Common Mistake #6: Getting confused or faked out by extension methods

As mentioned earlier, LINQ statements work on any object that implements IEnumerable. For example, the following simple function will add up the balances on any collection of accounts:

  public decimal SumAccounts(IEnumerable<Account> myAccounts) {
      return myAccounts.Sum(a => a.Balance);
  }

In the above code, the type of the myAccounts parameter is declared as IEnumerable<Account>. Since myAccounts references a Sum method (C# uses the familiar “dot notation” to reference a method on a class or interface), we’d expect to see a method called Sum() on the definition of the IEnumerable<T>interface. However, the definition of IEnumerable<T>, makes no reference to any Sum method and simply looks like this:

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

So where is the Sum() method defined? C# is strongly typed, so if the reference to the Sum method was invalid, the C# compiler would certainly flag it as an error. We therefore know that it must exist, but where? Moreover, where are the definitions of all the other methods that LINQ provides for querying or aggregating these collections?

The answer is that Sum() is not a method defined on the IEnumerable interface. Rather, it is a static method (called an “extension method”) that is defined on the System.Linq.Enumerable class:

  namespace System.Linq {
    public static class Enumerable {
      ...
      // the reference here to “this IEnumerable<TSource> source” is
      // the magic sauce that provides access to the extension method Sum
      public static decimal Sum<TSource>(this IEnumerable<TSource> source,
                                         Func<TSource, decimal> selector);
      ...
    }
  }

So what makes an extension method different from any other static method and what enables us to access it in other classes?

The distinguishing characteristic of an extension method is the this modifier on its first parameter. This is the “magic” that identifies it to the compiler as an extension method. The type of the parameter it modifies (in this case IEnumerable<TSource>) denotes the class or interface which will then appear to implement this method.

(As a side point, there’s nothing magical about the similarity between the name of the IEnumerable interface and the name of the Enumerable class on which the extension method is defined. This similarity is just an arbitrary stylistic choice.)

With this understanding, we can also see that the sumAccounts function we introduced above could instead have been implemented as follows:

  public decimal SumAccounts(IEnumerable<Account> myAccounts) {
      return Enumerable.Sum(myAccounts, a => a.Balance);
  }

The fact that we could have implemented it this way instead raises the question of why have extension methods at all? Extension methods are essentially a convenience of the C# language that enables you to “add” methods to existing types without creating a new derived type, recompiling, or otherwise modifying the original type.

Extension methods are brought into scope by including a using [namespace]; statement at the top of the file. You need to know which namespace includes the extension methods you’re looking for, but that’s pretty easy to determine once you know what it is you’re searching for.

When the C# compiler encounters a method call on an instance of an object, and doesn’t find that method defined on the referenced object class, it then looks at all extension methods that are within scope to try to find one which matches the required method signature and class. If it finds one, it will pass the instance reference as the first argument to that extension method, then the rest of the arguments, if any, will be passed as subsequent arguments to the extension method. (If the C# compiler doesn’t find any corresponding extension method within scope, it will throw an error.)

Extension methods are an example of “syntactic sugar” on the part of the C# compiler, which allows us to write code that is (usually) clearer and more maintainable. Clearer, that is, if you’re aware of their usage. Otherwise, it can be a bit confusing, especially at first.

While there certainly are advantages to using extension methods, they can cause problems and a cry for C# help for those developers who aren’t aware of them or don’t properly understand them. This is especially true when looking at code samples online, or at any other pre-written code. When such code produces compiler errors (because it invokes methods that clearly aren’t defined on the classes they’re invoked on), the tendency is to think the code applies to a different version of the library, or to a different library altogether. A lot of time can be spent searching for a new version, or phantom “missing library”, that doesn’t exist.

Even developers who are familiar with extension methods still get caught occasionally, when there is a method with the same name on the object, but its method signature differs in a subtle way from that of the extension method. A lot of time can be wasted looking for a typo or error that just isn’t there.

Use of extension methods in C# libraries is becoming increasingly prevalent. In addition to LINQ, the Unity Application Block and the Web API framework are examples of two heavily-used modern libraries by Microsoft which make use of extension methods as well, and there are many others. The more modern the framework, the more likely it is that it will incorporate extension methods.

Of course, you can write your own extension methods as well. Realize, however, that while extension methods appear to get invoked just like regular instance methods, this is really just an illusion. In particular, your extension methods can’t reference private or protected members of the class they’re extending and therefore cannot serve as a complete replacement for more traditional class inheritance.

Common Mistake #7: Using the wrong type of collection for the task at hand

C# provides a large variety of collection objects, with the following being only a partial list:
Array, ArrayList, BitArray, BitVector32, Dictionary<K,V>, HashTable, HybridDictionary, List<T>, NameValueCollection, OrderedDictionary, Queue, Queue<T>, SortedList, Stack, Stack<T>, StringCollection, StringDictionary.

While there can be cases where too many choices is as bad as not enough choices, that isn’t the case with collection objects. The number of options available can definitely work to your advantage. Take a little extra time upfront to research and choose the optimal collection type for your purpose. It will likely result in better performance and less room for error.

If there’s a collection type specifically targeted at the type of element you have (such as string or bit) lean toward using that one first. The implementation is generally more efficient when it’s targeted to a specific type of element.

To take advantage of the type safety of C#, you should usually prefer a generic interface over a non-generic one. The elements of a generic interface are of the type you specify when you declare your object, whereas the elements of non-generic interfaces are of type object. When using a non-generic interface, the C# compiler can’t type-check your code. Also, when dealing with collections of primitive value types, using a non-generic collection will result in repeated boxing/unboxing of those types, which can result in a significant negative performance impact when compared to a generic collection of the appropriate type.

Another common C# problem is to write your own collection object. That isn’t to say it’s never appropriate, but with as comprehensive a selection as the one .NET offers, you can probably save a lot of time by using or extending one that already exists, rather than reinventing the wheel. In particular, the C5 Generic Collection Library for C# and CLI offers a wide array of additional collections “out of the box”, such as persistent tree data structures, heap based priority queues, hash indexed array lists, linked lists, and much more.

Common Mistake #8: Neglecting to free resources

The CLR environment employs a garbage collector, so you don’t need to explicitly free the memory created for any object. In fact, you can’t. There’s no equivalent of the C++ delete operator or the free() function in C . But that doesn’t mean that you can just forget about all objects after you’re done using them. Many types of objects encapsulate some other type of system resource (e.g., a disk file, database connection, network socket, etc.). Leaving these resources open can quickly deplete the total number of system resources, degrading performance and ultimately leading to program faults.

While a destructor method can be defined on any C# class, the problem with destructors (also called finalizers in C#) is that you can’t know for sure when they will be called. They are called by the garbage collector (on a separate thread, which can cause additional complications) at an indeterminate time in the future. Trying to get around these limitations by forcing garbage collection with GC.Collect() is not a good practice, as that will block the thread for an unknown amount of time while it collects all objects eligible for collection.

This is not to say there are no good uses for finalizers, but freeing resources in a deterministic way isn’t one of them. Rather, when you’re operating on a file, network or database connection, you want to explicitly free the underlying resource as soon as you are done with it.

Resource leaks are a concern in almost any environment. However, C# provides a mechanism that is robust and simple to use which, if utilized, can make leaks a much rarer occurrence. The .NET framework defines the IDisposable interface, which consists solely of the Dispose() method. Any object which implements IDisposable expects to have that method called whenever the consumer of the object is finished manipulating it. This results in explicit, deterministic freeing of resources.

If you are creating and disposing of an object within the context of a single code block, it is basically inexcusable to forget to call Dispose(), because C# provides a using statement that will ensure Dispose() gets called no matter how the code block is exited (whether it be an exception, a return statement, or simply the closing of the block). And yes, that’s the same using statement mentioned previously that is used to include namespaces at the top of your file. It has a second, completely unrelated purpose, which many C# developers are unaware of; namely, to ensure that Dispose() gets called on an object when the code block is exited:

  using (FileStream myFile = File.OpenRead("foo.txt")) {
    myFile.Read(buffer, 0, 100);
  }

By creating a using block in the above example, you know for sure that myFile.Dispose() will be called as soon as you’re done with the file, whether or not Read() throws an exception.

Common Mistake #9: Shying away from exceptions

C# continues its enforcement of type safety into runtime. This allows you to pinpoint errors much more quickly than in languages such as C++, where faulty type conversions can result in arbitrary values being assigned to an object’s fields. However, once again, programmers can squander this great feature,leading to C# problems. They fall into this trap because C# provides two different ways of doing things, one which can throw an exception, and one which won’t. Some will shy away from the exception route, figuring that not having to write a try/catch block saves them some coding.

For example, here are two different ways to perform an explicit type cast in C#:

  // METHOD 1:
  // Throws an exception if account can't be cast to SavingsAccount
  SavingsAccount savingsAccount = (SavingsAccount)account;
  
  // METHOD 2:
  // Does NOT throw an exception if account can't be cast to
  // SavingsAccount; will just set savingsAccount to null instead
  SavingsAccount savingsAccount = account as SavingsAccount;

The most obvious error that could occur with the use of Method 2 would be a failure to check the return value. That would likely result in an eventual NullReferenceException, which could possibly surface at a much later time, making it much harder to track down the source of the problem. In contrast, Method 1 would have immediately thrown an InvalidCastException making the source of the problem much more immediately obvious.

Moreover, even if you remember to check the return value in Method 2, what are you going to do if you find it to be null? Is the method you’re writing an appropriate place to report an error? Is there something else you can try if that cast fails? If not, then throwing an exception is the correct thing to do, so you might as well let it happen as close to the source of the problem as possible.

Here are a couple of examples of other common pairs of methods where one throws an exception and the other does not:

  int.Parse();     // throws exception if argument can’t be parsed
  int.TryParse();  // returns a bool to denote whether parse succeeded
  
  IEnumerable.First();           // throws exception if sequence is empty
  IEnumerable.FirstOrDefault();  // returns null/default value if sequence is empty

Some programmers are so “exception adverse” that they automatically assume the method that doesn’t throw an exception is superior. While there are certain select cases where this may be true, it is not at all correct as a generalization.

As a specific example, in a case where you have an alternative legitimate (e.g., default) action to take if an exception would have been generated, then that the non-exception approach could be a legitimate choice. In such a case, it may indeed be better to write something like this:

  if (int.TryParse(myString, out myInt)) {
    // use myInt
  } else {
    // use default value
  }

instead of:

  try {
    myInt = int.Parse(myString);
    // use myInt
  } catch (FormatException) {
    // use default value
  }

However, it is incorrect to assume that TryParse is therefore necessarily the “better” method. Sometimes that’s the case, sometimes it’s not. That’s why there are two ways of doing it. Use the correct one for the context you are in, remembering that exceptions can certainly be your friend as a developer.

Common Mistake #10: Allowing compiler warnings to accumulate

While this problem is definitely not C# specific, it is particularly egregious in C# since it abandons the benefits of the strict type checking offered by the C# compiler.

Warnings are generated for a reason. While all C# compiler errors signify a defect in your code, many warnings do as well. What differentiates the two is that, in the case of a warning, the compiler has no problem emitting the instructions your code represents. Even so, it finds your code a little bit fishy, and there is a reasonable likelihood that your code doesn’t accurately reflect your intent.

A common simple example for the sake of this post is when you modify your algorithm to eliminate the use of a variable you were using, but you forget to remove the variable declaration. The program will run perfectly, but the compiler will flag the useless variable declaration. The fact that the program runs perfectly causes programmers to neglect to fix the cause of the warning. Furthermore, programmers take advantage of a Visual Studio feature which makes it easy for them to hide the warnings in the “Error List” window so they can focus only on the errors. It doesn’t take long until there are dozens of warnings, all of them blissfully ignored (or even worse, hidden).

But if you ignore this type of warning, sooner or later, something like this may very well find its way into your code:

  class Account {
  
      int myId;
      int Id;   // compiler warned you about this, but you didn’t listen!
  
      // Constructor
      Account(int id) {
          this.myId = Id;     // OOPS!
      }
  
  }

And at the speed Intellisense allows us to write code, this error isn’t as improbable as it looks.

You now have a serious error in your program (although the compiler has only flagged it as a warning, for the reasons already explained), and depending on how complex your program is, you could waste a lot of time tracking this one down. Had you paid attention to this warning in the first place, you would have avoided this problem with a simple five-second fix.

Remember, the C# compiler gives you a lot of useful information about the robustness of your code… if you’re listening. Don’t ignore warnings. They usually only take a few seconds to fix, and fixing new ones when they happen can save you hours. Train yourself to expect the Visual Studio “Error List” window to display “0 Errors, 0 Warnings”, so that any warnings at all make you uncomfortable enough to address them immediately.

Of course, there are exceptions to every rule. Accordingly, there may be times when your code will look a bit fishy to the compiler, even though it is exactly how you intended it to be. In those very rare cases, use #pragma warning disable [warning id] around only the code that triggers the warning, and only for the warning ID that it triggers. This will suppress that warning, and that warning only, so that you can still stay alert for new ones.

Must-have Tools for Developers

2018-07-29T07:55:00.000-07:00

Every developer has list of his favourite tools. These tools make developers more productive and make there life easier. Here are the list of my favourite tools. These are the tools which a developer must have apart from there IDEs. With time and changing focus, this list keeps changing.

LinqPad : LINQPad is not just for LINQ queries, but any C#/F#/VB expression, statement block or program. Put an end to those hundreds of Visual Studio Console projects cluttering your source folder and join the revolution of LINQPad scripters and incremental developers.

TMetric : TMetric is a work time tracker for freelancers, agencies, and companies. Light interface with great control over time intervals and projects’ budgets. Flexible billable rates and crystal clear reporting. Transparent team monitoring and lots of integrations.

Second Monitor : While you can accomplish most tasks with only one monitor, two monitors allow you to accomplish the same tasks in a fraction of the time. In fact, dual monitors have been proven to increase productivity by 20-30 percent, according to The New York Times’s report of a Jon Peddie Research survey.

ngrok : ngrok allows you to expose a web server running on your local machine to the internet. If you need to show the application running on your location machine to your client or someone who is not in you network this tool can help you in doing so.

SSD or SSHD : One thing that every programmer hates is slow system. Most of the programmers have pretty good amount of RAM and faster process in their systems, but still there system may not be as fast as they want, the reason could be HDD(Hard Disk Drive). You can replace HDD with SSD(Solid State Drive) or SSHD(Solid State Hybrid Drive). Like a memory stick, there are no moving parts to an SSD. Rather, information is stored in microchips. Conversely, a hard disk drive uses a mechanical arm with a read/write head to move around and read information from the right location on a storage platter. This difference is what makes SSD much faster.

CCleaner : Registry cleaner and makes your computer faster. There is one free version which you can download from there web site.

VirtualBox : It is one of the best VHD host and manager allowing you to create image of almost any OS and run it on Windows.

Uberconference : Hold large or small meetings and web conferences. This is one of my favorites allowing me schedule and manage my webinars.

JustDecompile : New, free developer productivity tool for easy .NET assembly browsing and decompiling and a complete replacement of .NET Reflector (since its no more free). You can also try ILSpy

HelpNDoc : Is a really great tool to generate documentation in PDF, Web-based, CHM, Word and iPhone for personal use.

Google Chrome : The Chrome Developer Tools (DevTools for short), are a set of web authoring and debugging tools built into Google Chrome. The DevTools provide web developers deep access into the internals of the browser and their web application. Use the DevTools to efficiently track down layout issues, set JavaScript breakpoints, and get insights for code optimization.

NimbleText : Thanks to Scott Hanselman, I have found this program – and my new favorite way to write repetitive code or handle small or large data transformation tasks. I’ve used it from everything from writing HTML to generating SQL insert scripts. Its time-saving power cannot be overstated. And, it’s FREE!

OzCode : If you’re a C# developer, you need OzCode. It turns debugging from a necessary chore to a borderline delight. Break down code expressions, highlight the most needed data in an object, compare data between two objects, find all objects of a given type in memory, and exceptional exception handling make OzCode a star – and that’s just the tip of the iceberg.

Dapper : When I want a way to quickly access a database using SQL, Dapper has my back. Deceptively simple API for what turns out to be a very fast way to access data. Powers the data access layer behind StackExchange, one of the highest traffic websites on the planet.

LastPass : A wonderful password manager that makes managing logins a much easier endeavor. When you’re in IT, you know how crucial it is to keep track of passwords and LastPass makes that much much easier.

Scott Hanselman’s Blog : Scott Hanselman is my main man. His blog posts are always interesting and valuable and his contributions to the Microsoft dev world cannot be overstated.

StackExchange : If StackExchange doesn’t have an answer to your programming question or problem, then you’re probably on your own. Learn from the wisdom of others’ mistakes and find quick, elegant solutions to your programming problems. Chase down those obscure exceptions. If you haven’t used it, then you’ve never used Google to solve a problem.

What is a web-hook?

2018-07-28T15:15:00.000-07:00

The concept of a WebHook is simple. A WebHook is an HTTP callback: an HTTP POST that occurs when something happens; a simple event-notification via HTTP POST.

A web application implementing WebHooks will POST a message to a URL when certain things happen. When a web application enables users to register their own URLs, the users can then extend, customize, and integrate that application with their own custom extensions or even with other applications around the web. For the user, WebHooks are a way to receive valuable information when it happens, rather than continually polling for that data and receiving nothing valuable most of the time. WebHooks have enormous potential and are limited only by your imagination! (No, it can’t wash the dishes. Yet.)

WebHooks are meant to do something. To get your imagination spinning with your own ideas, here are the three general ways in which WebHooks can be used to make your web more programmable:

Push: receiving data in real time

Push is the simplest of reasons to use WebHooks. As was just stated above, no more polling every couple of minutes to find out if there is new information. Just register a WebHook and receive the data at your doorstep as soon as it exists. It’s less work, less hassle, and you’ll probably even receive it sooner than if you were asking for it every couple of minutes.

Pipes: receiving data and passing it on

A Pipe happens when your WebHook not only receives real-time data, but goes on to do something new and meaningful with it, triggering actions unrelated to the original event. For example, you create a script, register its URL at a photo site, and have it email you when your mother posts a new photo. Or make a script that creates a Twitter message, and have it triggered by a WebHook whenever you add a new product on your commerce website.

Plugins: processing data and giving something in return

This is where the entire web becomes a programming platform. You can use this form of WebHooks to allow others to extend your application. Facebook’s Application Platform uses WebHooks in this way, and so does Google Wave’s robot integration. The general idea is that a web application sending out data via WebHooks will also use the response to modify its own data. At Facebook, when you access an app, Facebook sends a WebHook out to your application saying “Hey, someone’s accessing your application, what do I do?!” The application responds with, “Show the user this page…” Facebook does so, and the pattern continues in the same manner as you continue to use the application. At Google Wave, when you do something in a wave, any robot you’ve added as a participant is notified via a WebHook, and the robot has the ability to modify the wave in its http response. Implement WebHooks in this way in your application if you want to allow others to truly extend and enhance the abilities of your application.

How do they work?

By letting the user specify a URL for various events, the application will POST data to those URLs when the events occur. With the cheap availability of PHP hosting and even easier simple app/script hosting like AppJet or Scriptlets, handling the POST data becomes fairly trivial. How you use it is up to you and whatever you want to accomplish. Among other things, you can:

create notifications to you or anybody via email, IRC, Jabber, …
put the data in another app (real-time data synchronization)
process the data and repost it using the app’s API
validate the data and potentially prevent it from being used by the app

Why should I care?

As integrated as we perceive the web, most web applications today operate in silos. With the rise of API’s we’ve seen mashups and some degree of integration between applications. However, we have not seen the vision of the programmable web: a web where you as the user can “pipe” data between apps much like the Unix command line. Some say RSS is the answer. They are wrong. The heart is in the right place, but the implementation is wrong. RSS is still useful, but it is not going to bring us the true programmable web.

We just need a simple way to get data out in real-time to let the user easily do whatever they want with it. That means no polling, no content constraints, and no XML parsing. That means no RSS. Using HTTP is simpler and easier to use. PHP is a very popular and accessible programming environment, so it’s likely to be used often for writing hooklets… getting data from a web POST in PHP is as simple as $_POST[‘something’]. And making the request to the user script is as simple as making an HTTP request, something already built-in to most programming environments. In fact, web hooks are easier to implement than an API.

However implemented (although the easier the more likely it will be adopted), having an output for the web will complement the input provided by the rising adoption of API’s. When you have both input and output, you have everything you need for apps to easily interact. This will encourage smaller, more focused apps that together with hook-enabled heavier apps will let amazing emergent creations happen!

How do I implement WebHooks?

Simply provide your users with the ability to submit their own URL, and POST to that URL when something happens. It’s that simple. There are no specs you have to follow.

Azure storage emulator failed to initialize for Azure SDK 2.6

2018-07-28T15:14:00.001-07:00

As sudden, I started getting “Azure storage emulator failed to initialize for Azure SDK 2.6” when I try to run my cloud service in emulator. After searching on google for some time I found the solution. Here is that solution step by step. I am posting it here as I did not find a properly explained solution any where else on internet.

Step 1 : Start your system in safe mode (Immediately after the computer is powered on or restarted tap the F8 key to enter safe mode).

Step 2 : In safe mode go the path C:\Program Files (x86)\Microsoft SDKs\Azure\Storage Emulator.

Step 3 : Search for WAStorageEmulator.exe – config file.

Step 4 : Edit WAStorageEmulator.exe with Notepad++ (any editor).

Step 5 : Change the port numbers as shown in the above snapshot. (By default the port numbers will be 10000, 10001, 10002).

<services>
  <service name="Blob" url="http://127.0.0.1:30000/"/>
  <service name="Queue" url="http://127.0.0.1:30001/"/>
  <service name="Table" url="http://127.0.0.1:30002/"/>
</services>

Step 6 : Save the file and restart your system in normal mode and run the program.

I hope this helps.

What is LocalDB and How to use it?

2018-07-28T15:13:00.003-07:00

LocalDB is a new version of SQL Express. LocalDB is created specifically for developers. It is very easy to install and requires no management, yet it offers the same T-SQL language, programming surface and client-side providers as the regular SQL Server Express. In effect the developers that target SQL Server no longer have to install and manage a full instance of SQL Server Express on their laptops and other development machines. Moreover, if the simplicity (and limitations) of LocalDB fit the needs of the target application environment, developers can continue using it in production, as LocalDB makes a pretty good embedded database too.

LocalDB has the following key properties:

LocalDB uses the same sqlservr.exe as the regular SQL Express and other editions of SQL Server. The application is using the same client-side providers (ADO.NET, ODBC, PDO and others) to connect to it and operates on data using the same T-SQL language as provided by SQL Express.
LocalDB is installed once on a machine (per major SQL Server version). Multiple applications can start multiple LocalDB processes, but they are all started from the same sqlservr.exe executable file from the same disk location.
LocalDB doesn’t create any database services; LocalDB processes are started and stopped automatically when needed. The application is just connecting to “Data Source=(localdb)\v11.0” and LocalDB process is started as a child process of the application. A few minutes after the last connection to this process is closed the process shuts down.
LocalDB connections support AttachDbFileName property, which allows developers to specify a database file location. LocalDB will attach the specified database file and the connection will be made to it.

LocalDB Instances

As said before, at the heart of LocalDB is the same sqlservr.exe as in the regular SQL Express and other editions of SQL Server. In case of LocalDB, it is installed into one central location together with all necessary DLLs. By default it is located at “C:\Program Files\Microsoft SQL Server\110\LocalDB\Binn”.

When an application uses any of the client-side providers (like ADO.NET, ODBC or PDO) to connect to “Data Source=(localdb)\v11.0”, the provider will first check if LocalDB instance for the current user is started. If it’s already started the application will connect to it. Otherwise the LocalDB instance for the current user will be started and then the provider proceeds to connect to it. Note that each user (Windows login) may have their own LocalDB instance that is isolated from instances of other users.

Database as a File

LocalDB connection strings support AttachDbFileName property that allows attaching a database file during the connection process. This lets developers work directly with databases instead of the database server. Assuming a database file (*.MDF file with the corresponding *.LDF file) is stored at “C:\MyData\Database1.mdf” the developer can start working with it by simply using the following connection string: “Data Source=(localdb)\v11.0;Integrated Security=true;AttachDbFileName=C:\MyData\Database1.mdf”.

LocalDB and User Instances of SQL Express

Users familiar with today’s User Instances of SQL Server Express should feel right at home with LocalDB. In essence LocalDB offers the ability to create and start a “user instance” without the hassle of installing and maintaining the parent SQL Express instance. In that respect LocalDB could be seen as an upgrade of the User Instances feature of SQL Server Express.

LocalDB and SQL Express

LocalDB is not a replacement for SQL Server Express — it is an addition to SQL Server Express lineup. While LocalDB is meant for developers, the regular SQL Server Express will continue to exist as a free SQL Server edition, fully compatible with and easily upgradeable to higher SQL Server editions.

LocalDB and SQL Server Compact?

Small and simple database, lightweight installation, connecting to a database file — this will sound familiar to any developer using SQL Server Compact. The similarities are not accidental, as our goal for LocalDB was to be as easy to use as SQL Server Compact (while being as powerful and compatible with full SQL Server as SQL Express).

There are significant differences between LocalDB and SQL Server Compact:

Execution mode: SQL Server Compact is an in-proc DLL, while LocalDB runs as a separate process.
Disk usage: all SQL Server Compact binaries amount to some 4MBs, while LocalDB installation takes 140MBs.
Features: SQL Server Compact offers core RDBMS functionality like querying, while LocalDB provides a much richer set of features, including Stored Procedures, Geometry and Geography data types, etc.

Keyboard Shortcuts (Windows) to Boost Your Productivity

2018-07-28T15:13:00.001-07:00

General Shortcuts

Let’s kick start the list with the most common shortcuts that you’ll often use.

F1 [Display Help]
F2 [Rename the selected item]
F3 [Search for a file or folder]
F4 [Display the address bar list in File Explorer]
F5 [Refresh the active window]
F6 [Cycle through screen elements in a window or on the desktop]
F10 [Activate the Menu bar in the active app]
ALT + F4 [Close the active item, or exit the active app]
ALT + ESC [Cycle through items in the order in which they were opened]
ALT + Underlined Letter in menus and dialog box options [Perform the command for that letter]
ALT + ENTER [Display properties for the selected item]
ALT + SPACEBAR [Open the shortcut menu for the active window]
ALT + LEFT ARROW [Back]
ALT + RIGHT ARROW [Forward]
ALT + PAGE UP [Move up one screen]
ALT + PAGE DOWN [Move down one screen]
ALT + TAB [Switch between open apps (except desktop apps)]
CTRL + F4 [Close the active document (in apps that allow you to have multiple documents open simultaneously)]
CTRL + A [Select all items in a document or window]
CTRL + C or CTRL + INSERT [Copy the selected item]
CTRL + D / DELETE [DELETE the selected item and move it to the Recycle Bin]
CTRL + R or F5 [Refresh the active window]
CTRL + V or SHIFT + INSERT [Paste the selected item]
CTRL + X [Cut the selected item]
CTRL + Y [Redo an action]
CTRL + Z [Undo an action]
CTRL + + or CTRL + – [Zoom in or out of a large NUMBER of items, like apps pinned to the Start screen]
CTRL + mouse scroll wheel [Change the size of desktop icons or zoom in or out of a large NUMBER of items, like apps pinned to the Start screen]
CTRL + RIGHT ARROW [Move the cursor to the beginning of the next word]
CTRL + LEFT ARROW [Move the cursor to the beginning of the previous word]
CTRL + DOWN ARROW [Move the cursor to the beginning of the next paragraph]
CTRL + UP ARROW [Move the cursor to the beginning of the previous paragraph]
CTRL + ALT + TAB [Use the arrow keys to switch between all open apps]
CTRL + ARROW + SPACEBAR [Select multiple individual items in a window or on the desktop]
CTRL + SHIFT + ARROW [Select a block of text]
CTRL + ESC [Open the Start screen]
CTRL + SHIFT + ESC [Open Task Manager]
CTRL + SHIFT [Switch the keyboard layout when multiple keyboard layouts are available]
CTRL + SPACEBAR [Turn the Chinese input method editor (IME) on or off]
SHIFT + F10 [Display the shortcut menu for the selected item]
SHIFT + ARROW [Select more than one item in a window or on the desktop, or select text within a document]
SHIFT + DELETE [Delete the selected item without moving it to the Recycle Bin first]
RIGHT ARROW [Open the next menu to the right, or open a submenu]
LEFT ARROW [Open the next menu to the left, or close a submenu]
ESC [Stop or leave the current task]

Windows key Shortcuts

Let’s check the keyboard shortcuts involving the Windows logo key. Most of them are introduced in Windows 8’s Metro UI, and can be used in Windows 8 and above.

Win + F1 [Open Windows Help and support]
Win [Display or hide the Start screen]
Win + B [Set focus in the notification area]
Win + C [Open Charms]
Win + D [Display and hide the desktop]
Win + E [Open File Explorer]
Win + F [Open the Search charm and search for files]
Win + H [Open the Share charm]
Win + I [Open the Settings charm]
Win + K [Open the Devices charm]
Win + L [Lock your PC or switch people]
Win + M [Minimize all windows]
Win + O [Lock device orientation]
Win + P [Choose a presentation display mode]
Win + Q [Open the Search charm to search everywhere or within the open app (if the app supports app search)]
Win + R [Open the Run dialog box]
Win + S [Open the Search charm to search Windows and the web]
Win + T [Cycle through apps on the task bar]
Win + U [Open Ease of Access Center]
Win + V [Cycle through notifications]
Win + SHIFT + V [Cycle through notifications in reverse order]
Win + W [Open the Search charm and search for settings]
Win + X [Open the Quick Link menu]
Win + Z [Show the commands available in the app]
Win + , [Temporarily peek at the desktop]
Win + PAUSE [Display the System Properties dialog box]
Win + CTRL + F [Search for PCs (if you’re on a network)]
Win + SHIFT + M [Restore minimized windows on the desktop]
Win + (NUMBER 1-9) [Open the desktop and start the app pinned to the task bar in the position indicated by the number. If the app is already running, it switches to that app.]
Win + SHIFT + (NUMBER 1-9) [Open the desktop and start a new instance of the app pinned to the taskbar in the position indicated by the number]
Win + CTRL + (NUMBER 1-9) [Open the desktop and switch to the last active window of the app pinned to the taskbar in the position indicated by the number]
Win + ALT + (NUMBER 1-9) [Open the desktop and open the Jump List for the app pinned to the taskbar in the position indicated by the number]
Win + CTRL + SHIFT + (NUMBER 1-9) [Open the desktop and open a new instance of the app located at the given position on the taskbar as an administrator]
Win + TAB [Cycle through recently used apps (except desktop apps)]
Win + CTRL + TAB [Cycle through recently used apps (except desktop apps)]
Win + SHIFT + TAB [Cycle through recently used apps (except desktop apps) in reverse order]
Win + CTRL + B [Switch to the app that displayed a message in the notification area]
Win + UP ARROW [Maximize the window]
Win + DOWN ARROW [Remove current app from screen or minimize the desktop window]
Win + LEFT ARROW [Maximize the app or desktop window to the LEFT side of the screen]
Win + RIGHT ARROW [Maximize the app or desktop window to the RIGHT side of the screen]
Win + HOME [Minimize all but the active desktop window (restores all windows on second stroke)]
Win + SHIFT + UP ARROW [Stretch the desktop window to the top and bottom of the screen]
Win + SHIFT + DOWN ARROW [Restore/minimize active desktop windows vertically, maintaining width]
Win + SHIFT + LEFT ARROW or RIGHT ARROW [Move an app or window in the desktop from one monitor to another]
Win + SPACEBAR [Switch input language and keyboard layout]
Win + CTRL + SPACEBAR [Change to a previously selected input]
Win + ENTER [Open Narrator]
Win + SHIFT + . [Cycle through open apps]
Win + . [Cycle through open apps]
Win + / [Initiate IME reconversion]
Win + ALT + ENTER [Open WindowsMedia Center]
Win + +/- [Zoom in or out using Magnifier]
Win + ESC [Exit Magnifier]

Dialog box Shortcuts

These are the keyboard shortcuts that can be used in dialog boxes.

F1 [Display Help]
F4 [Display the items in the active list]
CTRL + TAB [Move forward through tabs]
CTRL + SHIFT + TAB [Move back through tabs]
CTRL + (NUMBER 1-9) [Move to nth tab]
TAB [Move forward through options]
SHIFT + TAB [Move back through options]
ALT + Underlined Letter in menus and dialog box options [Perform the command (or select the option) that goes with that letter]
SPACEBAR [Select or clear the check box if the active option is a check box]
BACKSPACE [Open a folder one level up if a folder is selected in the Save As or Open dialog box]
ARROW keys [Select a button if the active option is a group of option buttons]

File explorer Shortcuts

These are the shortcuts that can be used to work with File Explorer’s windows or folders.

ALT + D [Select the address bar]
CTRL + E [Select the search box]
CTRL + F [Select the search box]
CTRL + N [Open a new window]
CTRL + W [Close the current window]
CTRL + mouse scroll wheel [Change the size and appearance of file and folder icons]
CTRL + SHIFT + E [Display all folders above the selected folder]
CTRL + SHIFT + N [Create a new folder]
NUM LOCK + * [Display all subfolders under the selected folder]
NUM LOCK + + [Display the contents of the selected folder]
NUM LOCK + – [Collapse the selected folder]
ALT + P [Display the preview pane]
ALT + ENTER [Open the Properties dialog box for the selected item]
ALT + RIGHT ARROW [View the next folder]
ALT + UP ARROW [View the folder that the folder was in]
ALT + LEFT ARROW [View the previous folder]
BACKSPACE [View the previous folder]
RIGHT ARROW [Display the current selection (if it’s collapsed), or select the first subfolder]
LEFT ARROW [Collapse the current selection (if it’s expanded), or select the folder that the folder was in]
END [Display the bottom of the active window]
HOME [Display the top of the active window]
F11 [Maximize or minimize the active window]

Task bar Shortcuts

Here are the keyboard shortcuts to work with items on the Desktop’s taskbar.

SHIFT + Click a Taskbar Button [Open an app or quickly open another instance of an app]
CTRL + SHIFT + Click a Taskbar Button [Open an app as an administrator]
SHIFT + Right-click a Taskbar Button [Show the window menu for the app]
SHIFT + Right-click a Grouped Taskbar Button [Show the window menu for the groUP]
CTRL + Click a Grouped Taskbar Button [Cycle through the windows of the groUP]

Ease of access Shortcuts

These are the keyboard shortcuts to help you use your computer easily.

Hold RIGHT SHIFT for eight seconds [Turn Filter Keys on and off]
LEFT ALT + LEFT SHIFT + PRINT SCREEN [Turn High Contrast on or off]
LEFT ALT + LEFT SHIFT + NUM LOCK [Turn Mouse Keys on or off]
Press SHIFT five times [Turn Sticky Keys on or off]
Press NUM LOCK for five seconds [Turn Toggle Keys on or off]
Win + U [Open the Ease of Access Center]

Magnifier Shortcuts

Here are the keyboard shortcuts to help you use Magnifier.

Win + + [Zoom in]
Win + – [Zoom out]
CTRL + ALT + SPACEBAR [Preview the desktop in full-screen mode]
CTRL + ALT + D [Switch to docked mode]
CTRL + ALT + F [Switch to full-screen mode]
CTRL + ALT + I [Invert colors]
CTRL + ALT + L [Switch to lens mode]
CTRL + ALT + R [Resize the lens]
CTRL + ALT + ARROW keys [Pan in the direction of the ARROW keys]
Win + ESC [Exit Magnifier]

Narrator Shortcuts

These are the keyboard shortcuts to help you use Narrator.

SPACEBAR or ENTER [Activate current item]
TAB + ARROW Keys [Move around on the screen]
CTRL [Stop reading]
CAPS LOCK + D [Read item]
CAPS LOCK + M [Start reading]
CAPS LOCK + H [Read document]
CAPS LOCK + V [Repeat phrase]
CAPS LOCK + W [Read window]
CAPS LOCK + PAGE UP or PAGE DOWN [Increase or decrease the volume of the voice]
CAPS LOCK + +/- [Increase or decrease the speed of the voice]
CAPS LOCK + SPACEBAR [Do default action]
CAPS LOCK + LEFT or RIGHT ARROW [Move to previous/next item]
CAPS LOCK + F2 [Show commands for current item]
Caps + ESC [Exit Narrator]

Remote desktop connection Shortcuts

These are the keyboard shortcuts to ease the use of remote desktop connection.

ALT + PAGE UP [Move between apps, left to right]
ALT + PAGE DOWN [Move between apps, right to left]
ALT + INSERT [Cycle through apps in the order that they were started]
ALT + HOME [Display the Start screen]
CTRL + ALT + BREAK [Switch between a window and full screen]
CTRL + ALT + END [Display the Windows Security dialog box]
CTRL + ALT + HOME [In full-screen mode, activate the connection bar]
ALT + DELETE [Display the system menu]

CTRL + ALT + – [Place a copy of the active window, within the client, on the Terminal server clipboard (similar to ALT + PRINT SCREEN on a local PC)]
CTRL + ALT + + [Place a copy of the entire client window area on the Terminal server clipboard (similar to Print Screen on a local PC)]
CTRL + ALT + RIGHT ARROW [TAB out of the Remote Desktop controls to a control in the host app (for example, a button or a text box). Useful when the Remote Desktop controls are embedded in another (host) app.]
CTRL + ALT + LEFT ARROW [TABout of the Remote Desktop controls to a control in the host app (for example, a button or a text box). Useful when the Remote Desktop controls are embedded in another (host) app.]

Help viewer Shortcuts

These are the keyboard shortcuts that can be used with the help viewer.

F3 [Move the cursor to the search box]
F10 [Display the Options menu]
HOME [Move to the beginning of a topic]
END [Move to the end of a topic]
ALT + LEFT ARROW [Move back to the previously viewed topic]
ALT + RIGHT ARROW [Move to the next (previously viewed) topic]
ALT + HOME [Display the Help and support home page]
ALT + A [Display the customer support page]
ALT + C [Display the TABle of Contents]
ALT + N [Display the Connection Settings menu]
CTRL + F [Search the current topic]
CTRL + P [Print a topic]

Principles of Good Programming

2018-07-28T15:12:00.001-07:00

The principles of good programming are closely related to principles of good design and engineering. The following programming principles have helped me over the years become a better programmer, and I believe can help any developer become more efficient and to produce code which is easier to maintain and that has fewer defects.

DRY – Don’t repeat yourself – This is probably the single most fundamental tenet in programming is to avoid repetition. Many programming constructs exist solely for that purpose (e.g. loops, functions, classes, and more). As soon as you start repeating yourself (e.g. a long expression, a series of statements, same concept) create a new abstraction.

Abstraction Principle – Related to DRY is the abstraction principle “Each significant piece of functionality in a program should be implemented in just one place in the source code.”

KISS (Keep it simple, stupid!) – Simplicity (and avoiding complexity) should always be a key goal. Simple code takes less time to write, has fewer bugs, and is easier to modify.

Avoid Creating a YAGNI (You aren’t going to need it) – You should try not to add functionality until you need it.

Do the simplest thing that could possibly work – A good question to ask one’s self when programming is “What is the simplest thing that could possibly work?” This helps keep us on the path towards simplicity in the design.

Don’t make me think – This is actually the title of a book by Steve Krug on web usability that is also relevant in programming. The point is that code should be easily read and understood with a minimum of effort required. If code requires too much thinking from an observer to understand, then it can probably stand to be simplified

Open/Closed Principle – Software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification. In other words, don’t write classes that people can modify, write classes that people can extend.

Write Code for the Maintainer – Almost any code that is worth writing is worth maintaining in the future, either by you or by someone else. The future you who has to maintain code often remembers as much of the code, as a complete stranger, so you might as well always write for someone else. A memorable way to remember this is “Always code as if the person who ends up maintaining your code is a violent psychopath who knows where you live.”

Principle of least astonishment – The principle of least astonishment is usually referenced in regards to the user interface, but the same principle applies to written code. Code should surprise the reader as little as possible. The means following standard conventions, code should do what the comments and name suggest, and potentially surprising side effects should be avoided as much as possible.

Single Responsibility Principle – A component of code (e.g. class or function) should perform a single well defined task.

Minimize Coupling – Any section of code (code block, function, class, etc) should minimize the dependencies on other areas of code. This is achieved by using shared variables as little as possible. “Low coupling is often a sign of a well-structured computer system and a good design, and when combined with high cohesion, supports the general goals of high readability and maintainability”

Maximize Cohesion – Code that has similar functionality should be found within the same component.

Hide Implementation Details – Hiding implementation details allows change to the implementation of a code component while minimally affecting any other modules that use that component.

Law of Demeter – Code components should only communicate with their direct relations (e.g. classes that they inherit from, objects that they contain, objects passed by argument, etc.)

Avoid Premature Optimization – Don’t even think about optimization unless your code is working, but slower than you want. Only then should you start thinking about optimizing, and then only with the aid of empirical data. “We should forget about small efficiencies, say about 97% of the time: premature optimization is the root of all evil” – Donald Knuth.

Code Reuse is Good – Not very pithy, but as good a principle as any other. Reusing code improves code reliability and decrease development time.

Separation of Concerns – Different areas of functionality should be managed by distinct and minimally overlapping modules of code.

Embrace Change – This is the subtitle of a book by Kent Beck, and is also considered a tenet of extreme programming and the agile methodology in general. Many other principles are based on the concept that you should expect and welcome change. In fact very old software engineering principles like minimizing coupling are related directly to the requirement of making code easier to change. Whether or not you are an extreme programming practitioner, this approach to writing code just makes sense.

Prefer Composition over Inheritance – The “composition over inheritance” principle states that objects with complex behaviors should do so by containing instances of objects with individual behaviors rather than inheriting a class and adding new behaviors.

Over reliance on inheritance can lead to two major issues. First, the inheritance hierarchy can become messy in the blink of an eye. Second, you have less flexibility for defining special-case behaviors, particularly when you want to implement behavior from one inheritance branch in another inheritance branch:

Composition is a lot cleaner to write, easier to maintain, and allows for near-infinite flexibility as far as what kinds of behaviors you can define. Each individual behavior is its own class, and you create complex behaviors by combining individual behaviors.

Refactor, Refactor and Refactor – One of the hardest truths to accept as an inexperienced programmer is that code rarely comes out right the first time. It may feel right when you implement that shiny new feature, but as your program grows in complexity, future features may be hindered by how you wrote that early one. Code bases are constantly evolving. It’s completely normal to revisit, rewrite, or even redesign entire chunks of code — and not just normal, but healthy to do so. You know more about your project’s needs now than when you did at the start, and you should regularly use this newly gained knowledge to refactor old code.

Clean code is better then Cleaver Code – Speaking of clean code, leave your ego at the door and forget about writing clever code. You know what I’m talking about: the kind of codee that looks more like a riddle than a solution and exists solely to show off how smart you are. The truth is, nobody really cares.

One example of clever code is packing as much logic into one line as possible. Another example is exploiting a language’s intricacies to write strange but functional statements. Anything that might cause someone to say “Wait, what?” when poring over your code.

Accessing File Stored in Windows Azure Blob Storage Using jQuery

2018-07-28T15:11:00.003-07:00

Did you know it was possible to access the Windows Azure Blob Storage directly from JavaScript, for example using jQuery?

At first, it sounds obvious, since Blobs are after all accessible from a public UR. But in practice, there is a very big hurdle: the Web browser’s Same Origine Policy or SOP, that restricts JavaScript code to accessing resources originating from the same site the script was loaded from. This means that you will never be able to load a Windows Azure Blob using XMLHttpRequest for example!

Fortunately, there is a popular workaround called JSONP (“JSON with Padding”). The idea behind this technique is that the script tag is not submitted to the SOP: an HTML page can thus load a JavaScript file from any site. So, if you expose your data in an “executable” form in JavaScript, a page will be able to load this data using a script tag. For example:

<script type=”text/javascript” src=”http://www.sandeepknarware.in/exemple.jsonp”>
</script>

But how can you make data executable? This is what the “Padding” in JSONP is about: you are going to pad, or surround, your JSON data with a function call. In my example, the exemple.jsonp file could contain:

jsonpCallback({“Nom”: “Thomas”, “Id” : 42,})

When this script will be loaded by the script tag, this will trigger a call to a jsonpCallback function that will receive the JSON data as a parameter.

It is thus very simple to adapt this technique to Windows Azure Storage! All we need to do is to create Blob conforming to the JSONP convention, and we will be able to call them from a JavaScript program.

Here is for example a sample JSON Blob on my public Windows Azure Storage. It is fairly large (more than 200 KB) and contains a data structure describing the most popular Facebook “likes” from my friends (no surprise, lots of Microsoft-related stuff in there!) The data structure itself is organized as a JavaScript array of objects like this:

[
{
“Nb”: 60,
“Id”: “129459787073480”,
“Name”: “Developpeurs”,
“Category”: “Product/service”,
“Timestamp”: “/Date(1312886077750)/”,
“PartitionKey”: “687276944”,
“RowKey”: “129459787073480”
},
{
“Nb”: 44,
“Id”: “343983715428”,
“Name”: “Windows Phone France”,
“Category”: “Product/service”,
“Timestamp”: “/Date(1312886077780)/”,
“PartitionKey”: “687276944”,
“RowKey”: “343983715428”
},
{
“Nb”: 43,
“Id”: “192285182795”,
“Name”: “Visual Studio 2010 en France”,
“Category”: “Product/service”,
“Timestamp”: “/Date(1312886081737)/”,
“PartitionKey”: “687276944”,
“RowKey”: “192285182795”
},
{
“Nb”: 40,
“Id”: “20528438720”,
“Name”: “Microsoft”,
“Category”: “Company”,
“Timestamp”: “/Date(1312886077553)/”,
“PartitionKey”: “687276944”,
“RowKey”: “20528438720”
}
]

All you need to do is to surround this data structure with a function call to e.g. dataCallback:

dataCallback(…your JSON goes here…)

Once you have your data stored as JSON Blobs, all you need to do is to load it, and in order to simplify the (many) implementation details, I will use jQuery’s excellent AJAX functions, that perfectly well equipped to deal with JSONP ; all you need to do is find the right parameters.

$.ajax({
url: ‘http://tcontepub.blob.core.windows.net/json/687276944.json’,
dataType: ‘jsonp’,
jsonpCallback: ‘dataCallback’,
success: function(data) {
$.each(data, function(i, v) {
$(‘#likes’).append($(‘<li>’, {
text: v.Name
}));
});
}
});

Nothing really remarkable, all you need to do is to pass to jQuery the same callback name you used in your JSONP file! This is what the following parameter does:

Temporal Tables in Azure SQL Database

2018-07-28T15:11:00.001-07:00

Temporal Tables allow you to track the full history of data changes directly in Azure SQL Database, without the need for custom coding. With Temporal Tables you can see your data as of any point in time in the past and use declarative cleanup policy to control retention for the historical data.

When to use Temporal Tables?

Quite often you may be in the situation to ask yourself fundamental questions: How did important information look yesterday, a month ago, a year ago, etc. What changes have been made since the beginning of the year? What were the dominant trends during a specific period of time? Without proper support in the database, however, questions like these have never been easy to answer.
Temporal Tables are designed to improve your productivity when you develop applications that work with ever-changing data and when you want to derive important insights from the changes.
Use Temporal Tables to:

Support data auditing in your applications
Analyze trends or detect anomalies over time
Easily implement slowly changing dimension pattern
Perform fine-grained row repairs in case of accidental data errors made by humans or applications

Manage historical data with easy-to-use retention policy

Keeping history of changes tends to increase database size, especially if historical data is retained for a longer period of time. Hence, retention policy for historical data is an important aspect of planning and managing the lifecycle of every temporal table. Temporal Tables in Azure SQL Database come with an extremely easy-to-use retention mechanism. Applying retention policy is very simple: it requires users to set single parameter during the table creation or table schema change, like shown in the following example.

ALTER TABLE [WebSiteClicks]
SET 
(
 SYSTEM_VERSIONING = ON 
 (
  HISTORY_TABLE = dbo. WebSiteClicks_History, 
                HISTORY_RETENTION_PERIOD = 3 MONTHS  
 )
);

You can alter retention policy at any moment and your change will be effective immediately.

Why you should consider Temporal Tables?

If you have requirements for tracking data changes, using Temporal Tables will give you multiple benefits over any custom solution. Temporal Tables will simplify every phase in the development lifecycle: object creation, schema evolution, data modification, point-in-time analysis and data aging.

Concatenate All Column Values in Sql

2018-07-28T15:10:00.004-07:00

If you work with the SQL you might have came across this question sometime. How to Concatenate all column values from different rows returned from a SQL query into one value?

This is an example:

a query returns:

FOO
------
RES1

RES2

RES3

now we want to have a result like the following one:

FOOCONCAT
-----
RES1RES2RES3

Here is the solution

In SQL Server:

SELECT  col1 AS [text()]
FROM    foo
FOR XML PATH ('')

In MySQL:

SELECT  GROUP_CONCAT(col1 SEPARATOR '')
FROM    foo

In PostgreSQL:

SELECT  array_to_string
        (
        ARRAY
        (
        SELECT  col1
        FROM    foo
        ), ''
        )

In Oracle:

SELECT  *
FROM    (
        SELECT  col1, ROW_NUMBER() OVER(ORDER BY 1) AS rn
        FROM    foo
        MODEL
        DIMENSION BY
                (rn)
        MEASURES
                (col1, col1 AS group_concat, 0 AS mark)
        RULES UPDATE (
                group_concat[rn > 1] =  group_concat[CV() - 1] || col1[CV()],
                mark[ANY] = PRESENTV(mark[CV() + 1], 0, 1)
                )
        )
WHERE   mark = 1

How to Copy Azure SQL Database to Local SQL Server

2018-07-28T15:10:00.002-07:00

Azure SQL Database is a relational database-as-a service using the Microsoft SQL Server Engine. SQL Database is a high-performance, reliable, and secure database you can use to build data-driven applications and websites in the programming language of your choice, without needing to manage infrastructure.

Some times you may want to create a copy of azure database on you local server. So that you can use it for development and bugging activities.

Here’s what you do when you want to get a local copy of an Azure SQL Database.

Export Azure Database

Select your database in the Azure Portal.
Click Export in the Header
Give it a name, storage, container, etc and start the export.
Once export is completed. Select your server and scroll to the bottom and click on Import/Export History

Import to Local SQL Server

Once the Export has completed, you now Import it to your local machine. This works with SQL Express too, just install the BOTH x86 and x64 versions of the DAC Framework first: https://www.microsoft.com/en-us/download/details.aspx?id=45886

Open SQL Management Studio and Right Click on Databases and Select Import Data-tier Application
Connect to your Azure Database Export and click Next a couple of times.

That should be it. If it fails, make sure you install the DAC Framework as mentioned above.

If you are more comfortable with the CLI, then you can use following commands to restore a local copy Azure SQL DB on you local SQL Server.

Using msdeploy.exe

msdeploy.exe fails to create the destination database on its own, so you need to create it manually first.

Copy the connection string on the database properties page. Adjust it so that it contains a correct password.
Get the connection string for the destination DB.
Run msdeploy.exe like this:

"c:\Program Files\IIS\Microsoft Web Deploy V3\msdeploy.exe" -verb:sync -dest:dbDacFx="destination_DB_connection_string",dropDestinationDatabase=true -source:dbDacFx="azure_DB_connection_string",includeData=true -verbose

Using SqlPackage.exe

Export the azure DB to a bacpac package.

"c:\Program Files (x86)\Microsoft SQL Server\110\DAC\bin\SqlPackage.exe" /a:Export /ssn:"azure_db_server" /sdn:"azure_db_name" /su:"user_name" /sp:"password" /tf:"file.bacpac"

2. Import the package to a local DB.

"c:\Program Files (x86)\Microsoft SQL Server\110\DAC\bin\SqlPackage.exe" /a:Import /SourceFile:"file.bacpac" /TargetServerName:".\SQLEXPRESS" /TargetDatabaseName:CopyOfAzureDb

Creating Indexes with Included Columns

2018-07-28T15:09:00.001-07:00

A nonclustered index can be extended by including nonkey columns in addition to the index key columns. The nonkey columns are stored at the leaf level of the index b-tree. Indexes that include nonkey columns provide the greatest benefit when they cover the query. This means the indexes include all columns referenced by the query.

Adding nonkey columns to the index uses more disk space to store the index. In particular, adding varchar(max), nvarchar(max), varbinary(max), or xml data types as nonkey columns may significantly increase disk space requirements, because the column values are copied into the index leaf level and also remain in the table or clustered index.

Performance gains are achieved in select operations because the query optimizer can locate all the required column data within the index; the table or clustered index is not accessed. However, having too many included columns may increase the time that is required to perform insert, update, or delete operations to the underlying table or indexed view because of increased index maintenance.

Covering a query

The following example creates a nonclustered index on the Person.Address table with four included columns. The index key column is PostalCode and the nonkey columns are AddressLine1, AddressLine2, City, and StateProvinceID.

CREATE NONCLUSTERED INDEX IX_Address_PostalCode
ON Person.Address (PostalCode)
INCLUDE (AddressLine1, AddressLine2, City, StateProvinceID);
GO

This query will be covered by the index.

SELECT AddressLine1, AddressLine2, City, StateProvinceID, PostalCode
FROM Person.Address
WHERE PostalCode BETWEEN '98000' and '99999';
GO

Exceeding the index size limitation
In the following example, the INCLUDE clause of the CREATE INDEX statement is used to index columns that would typically exceed the 900-byte maximum key column size limitation. The Production.ProductReview table contains these columns: ProductID (int), ReviewerName (nvarchar (50)) and Comments (nvarchar (3850)). These columns are frequently used in queries, but the Comments column is too large to participate as an index key column. However, by using the INCLUDE clause, the Comments column can be added as a nonkey column in the index.


CREATE NONCLUSTERED INDEX IX_ProductReview_ProductID_ReviewerName
ON Production.ProductReview (ProductID, ReviewerName)
INCLUDE (Comments);
GO



This query will be covered by the index.

SELECT Comments
FROM Production.ProductReview 
WHERE ProductID = 937;
GO

Web Forms, ASP.NET MVC, and ASP.NET Web Pages

2018-07-28T15:02:00.001-07:00

ASP.NET offers three frameworks for creating web applications: Web Forms, ASP.NET MVC, and ASP.NET Web Pages. All three frameworks are stable and mature, and you can create great web applications with any of them. No matter what framework you choose, you will get all the benefits and features of ASP.NET everywhere.

Each framework targets a different development style. The one you choose depends on a combination of your programming assets (knowledge, skills, and development experience), the type of application you’re creating, and the development approach you’re comfortable with.

Below is an overview of each of the frameworks and some ideas for how to choose between them.

	IF YOU HAVE EXPERIENCE IN	DEVELOPMENT STYLE	EXPERTISE
Web Forms	Win Forms, WPF, .NET	Rapid development using a rich library of controls that encapsulate HTML markup	Mid-Level, Advanced RAD
MVC	Ruby on Rails, .NET	Full control over HTML markup, code and markup separated, and easy to write tests. The best choice for mobile and single-page applications (SPA).	Mid-Level, Advanced
Web Pages	Classic ASP, PHP	HTML markup and your code together in the same file	New, Mid-Level

Web Forms

With ASP.NET Web Forms, you can build dynamic websites using a familiar drag-and-drop, event-driven model. A design surface and hundreds of controls and components let you rapidly build sophisticated, powerful UI-driven sites with data access.

MVC

ASP.NET MVC gives you a powerful, patterns-based way to build dynamic websites that enables a clean separation of concerns and that gives you full control over markup for enjoyable, agile development. ASP.NET MVC includes many features that enable fast, TDD-friendly development for creating sophisticated applications that use the latest web standards.1

ASP.NET Web Pages

ASP.NET Web Pages and the Razor syntax provide a fast, approachable, and lightweight way to combine server code with HTML to create dynamic web content. Connect to databases, add video, link to social networking sites, and include many more features that help you create beautiful sites that conform to the latest web standards.

Notes about Web Forms, MVC, and Web Pages

All three ASP.NET frameworks are based on the .NET Framework and share core functionality of .NET and of ASP.NET. For example, all three frameworks offer a login security model based around membership, and all three share the same facilities for managing requests, handling sessions, and so on that are part of the core ASP.NET functionality.

In addition, the three frameworks are not entirely independent, and choosing one does not preclude using another. Since the frameworks can coexist in the same web application, it’s not uncommon to see individual components of applications written using different frameworks. For example, customer-facing portions of an app might be developed in MVC to optimize the markup, while the data access and administrative portions are developed in Web Forms to take advantage of data controls and simple data access.

The 10 Most Common Mistakes That C# Developers Make

2018-07-28T15:00:00.002-07:00

Common Mistake #1: Using a reference like a value or vice versa

If you don’t know whether the object you’re using is a value type or reference type, you could run into some surprises. For example:

 Point point1 = new Point(20, 30);
  Point point2 = point1;
  point2.X = 50;
  Console.WriteLine(point1.X);       // 20 (does this surprise you?)
  Console.WriteLine(point2.X);       // 50
  
  Pen pen1 = new Pen(Color.Black);
  Pen pen2 = pen1;
  pen2.Color = Color.Blue;
  Console.WriteLine(pen1.Color);     // Blue (or does this surprise you?)
  Console.WriteLine(pen2.Color);     // Blue

The answer is to look at the definitions of the object types (which you can easily do in Visual Studio by placing your cursor over the name of the object type and pressing F12):

  public struct Point { … }     // defines a “value” type
  public class Pen { … }        // defines a “reference” type

As shown above, in C#, the struct keyword is used to define a value type, while the classkeyword is used to define a reference type. For those with a C++ background, who were lulled into a false sense of security by the many similarities between C++ and C# keywords, this behavior likely comes as a surprise that may have you asking for help from a C# tutorial.

Common Mistake #2: Misunderstanding default values for uninitialized variables

  class Program {
      static Point point1;
      static Pen pen1;
      static void Main(string[] args) {
          Console.WriteLine(pen1 == null);      // True
          Console.WriteLine(point1 == null);    // False (huh?)
      }
  }

Many (but not all) value types have an IsEmpty property which you can check to see if it is equal to its default value:

  Console.WriteLine(point1.IsEmpty);        // True

When you’re checking to see if a variable has been initialized or not, make sure you know what value an uninitialized variable of that type will have by default and don’t rely on it being null..

Common Mistake #3: Using improper or unspecified string comparison methods

There are many different ways to compare strings in C#.

Rather, the preferred way to test for string equality in C# is with the Equals method:

  public bool Equals(string value);
  public bool Equals(string value, StringComparison comparisonType);

  string s = "strasse";
  
  // outputs False:
  Console.WriteLine(s == "straße");
  Console.WriteLine(s.Equals("straße"));
  Console.WriteLine(s.Equals("straße", StringComparison.Ordinal));
  Console.WriteLine(s.Equals("Straße", StringComparison.CurrentCulture));        
  Console.WriteLine(s.Equals("straße", StringComparison.OrdinalIgnoreCase));
  
  // outputs True:
  Console.WriteLine(s.Equals("straße", StringComparison.CurrentCulture));
  Console.WriteLine(s.Equals("Straße", StringComparison.CurrentCultureIgnoreCase));

The safest practice is to always provide a comparisonType parameter to the Equals method. Here are some basic guidelines:

When comparing strings that were input by the user, or are to be displayed to the user, use a culture-sensitive comparison (CurrentCulture or CurrentCultureIgnoreCase).
When comparing programmatic strings, use ordinal comparison (Ordinal or OrdinalIgnoreCase).
InvariantCulture and InvariantCultureIgnoreCase are generally not to be used except in very limited circumstances, because ordinal comparisons are more efficient. If a culture-aware comparison is necessary, it should usually be performed against the current culture or another specific culture.

Common Mistake #4: Using iterative (instead of declarative) statements to manipulate collections

  decimal total = 0;
  foreach (Account account in myAccounts) {
    if (account.Status == "active") {
      total += account.Balance;
    }
  }

you could just write:

  decimal total = (from account in myAccounts
                   where account.Status == "active"
                   select account.Balance).Sum();

Common Mistake #5: Failing to consider the underlying objects in a LINQ statement

For instance, consider the following statement:

  decimal total = (from account in myAccounts
                   where account.Status == "active"
                   select account.Balance).Sum();

Common Mistake #6: Getting confused or faked out by extension methods

As mentioned earlier, LINQ statements work on any object that implements IEnumerable. For example, the following simple function will add up the balances on any collection of accounts:

  public decimal SumAccounts(IEnumerable<Account> myAccounts) {
      return myAccounts.Sum(a => a.Balance);
  }

In the above code, the type of the myAccounts parameter is declared as IEnumerable<Account>. Since myAccounts references a Sum method (C# uses the familiar “dot notation” to reference a method on a class or interface), we’d expect to see a method called Sum() on the definition of the IEnumerable<T> interface. However, the definition of IEnumerable<T>, makes no reference to any Sum method and simply looks like this:

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

  namespace System.Linq {
    public static class Enumerable {
      ...
      // the reference here to “this IEnumerable<TSource> source” is
      // the magic sauce that provides access to the extension method Sum
      public static decimal Sum<TSource>(this IEnumerable<TSource> source,
                                         Func<TSource, decimal> selector);
      ...
    }
  }

So what makes an extension method different from any other static method and what enables us to access it in other classes?

With this understanding, we can also see that the sumAccounts function we introduced above could instead have been implemented as follows:

  public decimal SumAccounts(IEnumerable<Account> myAccounts) {
      return Enumerable.Sum(myAccounts, a => a.Balance);
  }

Common Mistake #7: Using the wrong type of collection for the task at hand

Common Mistake #8: Neglecting to free resources

The CLR environment employs a garbage collector, so you don’t need to explicitly free the memory created for any object. In fact, you can’t. There’s no equivalent of the C++ deleteoperator or the free() function in C . But that doesn’t mean that you can just forget about all objects after you’re done using them. Many types of objects encapsulate some other type of system resource (e.g., a disk file, database connection, network socket, etc.). Leaving these resources open can quickly deplete the total number of system resources, degrading performance and ultimately leading to program faults.

  using (FileStream myFile = File.OpenRead("foo.txt")) {
    myFile.Read(buffer, 0, 100);
  }

By creating a using block in the above example, you know for sure that myFile.Dispose() will be called as soon as you’re done with the file, whether or not Read() throws an exception.

Common Mistake #9: Shying away from exceptions

For example, here are two different ways to perform an explicit type cast in C#:

  // METHOD 1:
  // Throws an exception if account can't be cast to SavingsAccount
  SavingsAccount savingsAccount = (SavingsAccount)account;
  
  // METHOD 2:
  // Does NOT throw an exception if account can't be cast to
  // SavingsAccount; will just set savingsAccount to null instead
  SavingsAccount savingsAccount = account as SavingsAccount;

The most obvious error that could occur with the use of Method 2 would be a failure to check the return value. That would likely result in an eventual NullReferenceException, which could possibly surface at a much later time, making it much harder to track down the source of the problem. In contrast, Method 1 would have immediately thrown an InvalidCastExceptionmaking the source of the problem much more immediately obvious.

Here are a couple of examples of other common pairs of methods where one throws an exception and the other does not:

  int.Parse();     // throws exception if argument can’t be parsed
  int.TryParse();  // returns a bool to denote whether parse succeeded
  
  IEnumerable.First();           // throws exception if sequence is empty
  IEnumerable.FirstOrDefault();  // returns null/default value if sequence is empty

  if (int.TryParse(myString, out myInt)) {
    // use myInt
  } else {
    // use default value
  }

instead of:

  try {
    myInt = int.Parse(myString);
    // use myInt
  } catch (FormatException) {
    // use default value
  }

Common Mistake #10: Allowing compiler warnings to accumulate

While this problem is definitely not C# specific, it is particularly egregious in C# since it abandons the benefits of the strict type checking offered by the C# compiler.

But if you ignore this type of warning, sooner or later, something like this may very well find its way into your code:

  class Account {
  
      int myId;
      int Id;   // compiler warned you about this, but you didn’t listen!
  
      // Constructor
      Account(int id) {
          this.myId = Id;     // OOPS!
      }
  
  }

And at the speed Intellisense allows us to write code, this error isn’t as improbable as it looks.

Dependency Injection

2018-07-28T15:00:00.000-07:00

In software engineering, dependency injection is a software design pattern that implements inversion of control for resolving dependencies. A dependency is an object that is be used in a class as service. An injection is the passing of a dependency to a dependent object (a client) that would use it. The service is made part of the client’s state. Passing the service to the client, rather than allowing a client to build or find the service, is the fundamental requirement of the pattern.

Dependency injection allows a program design to follow the dependency inversion principle. The client delegates to external code (the injector) the responsibility of providing its dependencies. The client is not allowed to call the injector code. It is the injecting code that constructs the services and calls the client to inject them. This means the client code does not need to know about the injecting code. The client does not need to know how to construct the services. The client does not need to know which actual services it is using. The client only needs to know about the intrinsic interfaces of the services because these define how the client may use the services. This separates the responsibilities of use and construction.

Dependency injection separates the creation of a client’s dependencies from the client’s behavior, which allows program designs to be loosely coupled and to follow the dependency inversion and single responsibility principles. It directly contrasts with the service locator pattern, which allows clients to know about the system they use to find dependencies.

An injection, the basic unit of dependency injection, is not a new or a custom mechanism. It works in the same way that “parameter passing” works. Referring to “parameter passing” as an injection carries the added implication that it’s being done to isolate the client from details.

Dependency injection involves four roles:

the service object(s) to be used
the client object that is depending on the services it uses
the interface that define how the client may use the services
the injector, which is responsible for constructing the services and injecting them into the client

Any object that may be used can be considered a service. Any object that uses other objects can be considered a client. The names have nothing to do with what the objects are for and everything to do with the role the objects play in any one injection.

The interfaces are the types the client expects its dependencies to be. hey may truly be interface types implemented by the services but also may be abstract classes.

Given that the client has no concrete knowledge, so long as the what the client uses, the interfaces name and methods, then the client won’t need to change even if what is behind the interface changes. However, if the interface is refactored from being a class to an interface type (or vice versa) the client will need to be recompiled.This is significant if the client and services are published separately. This unfortunate coupling is one that dependency injection cannot resolve.

The injector introduces the services into the client. Often, it also constructs the client. An injector may connect together a very complex object graph by treating an object like a client and later as a service for another client. The injector may be referred to by other names such as: assembler, provider, container, factory, builder, spring, construction code, or main.

Advantages

Dependency injection allows a client to remove all knowledge of a concrete implementation that it needs to use. This helps isolate the client from the impact of design changes and defects. It promotes reusability, testability and maintainability.
Reduction of boilerplate code in the application objects since all work to initialize or set up dependencies is handled by a provider component.
Dependency injection allows concurrent or independent development. Two developers can independently develop classes that use each other, while only needing to know the interface the classes will communicate through. Plugins are often developed by third party shops that never even talk to the developers who created the product that uses the plugins.
Dependency Injection decreases coupling between a class and its dependency.

Disadvantages

Dependency injection creates clients that demand configuration details be supplied by construction code. This can be onerous when obvious defaults are available.
Dependency injection can make code difficult to trace (read) because it separates behavior from construction. This means developers must refer to more files to follow how a system performs.
Dependency injection forces complexity to move out of classes and into the linkages between classes which might not always be desirable or easily managed.
Ironically, dependency injection can encourage dependence on a dependency injection framework.

In the following C# example, the Client class contains a Service member variable that is initialized by the Client constructor. The client controls which implementation of service is used and controls its construction. In this situation, the client is said to have a hard-coded dependency on ServiceExample.

// An example without dependency injection
public class Client {
    // Internal reference to the service used by this client
    private Service service;

    // Constructor
    public Client() {
        // Specify a specific implementation in the constructor 
        //instead of using dependency injection
        service = new ServiceExample();
    }

    // Method within this client that uses the services
    public String greet() {
        return "Hello " + service.getName();
    }
}

Dependency injection is an alternative technique to initialize the member variable rather than explicitly creating a service object as shown above.

Three types of dependency injection

There are at least three ways an object can receive a reference to an external module:

constructor injection: the dependencies are provided through a class constructor.
property injection: the client exposes a property that the injector uses to inject the dependency.
interface injection: the dependency provides an injector method that will inject the dependency into any client passed to it. Clients must implement an interface that exposes a property that accepts the dependency.

Constructor injection

This method requires the client to provide a parameter in a constructor for the dependency.

// Constructor
Client(Service service) {
    // Save the reference to the passed-in service inside this client
    this.service = service;
}

Setter injection

This method requires the client to provide a property for each dependency.

// Property
public void setService(Service service) {
    // Save the reference to the passed-in service inside this client
    this.service = service;
}

Interface injection

This is simply the client publishing a role interface to the property of the client’s dependencies. It can be used to establish how the injector should talk to the client when injecting dependencies.

// Service interface.
public interface ServiceSetter {
    public void setService(Service service);
}

// Client class
public class Client : ServiceSetter {
    // Internal reference to the service used by this client.
    private Service service;

    // Set the service that this client is to use.
    @Override
    public void setService(Service service) {
        this.service = service;
    }
}

What is the default Capacity of List(Stack, Queue)?

2018-07-28T14:59:00.002-07:00

Under the hood Lists (Stacks and Queues) rely on array to store their items. Whenever we create a empty list the default capacity of the list will be 0. At this time the underline array will be empty. In the code below we are creating an empty list and then we are writing its capacity in console.

List<int> number = new List<int>();
Console.WriteLine(number.Capacity);

The code returns 0. Now lets add an item to the list.

List<int> number = new List<int>();
number.Add(10);
Console.WriteLine(number.Capacity);
Console.ReadLine();

If we run this code it shows 4 as capacity, but we added only 1 item then why we are getting 4 as capacity?

Actually, it starts with a Capacity of 0. When you add the first element, the current implementation allocates a capacity of 4. After that, the capacity keeps doubling if expansion is needed, to guarantee amortized O(1) operation. Code below should demonstrate the current behavior

List<int> list = new List<int>();
int capacity = list.Capacity;
Console.WriteLine(“Capacity: ” + capacity);
for (int i = 0; i < 100000; i++)
{
list.Add(i);
if (list.Capacity > capacity)
{
capacity = list.Capacity;
Console.WriteLine(“Capacity: ” + capacity);
}
}
Console.ReadLine();

In simpler words whenever we add first element in the list, framework creates an array of size 4 and use it to store list’s elements. As soon as we add 5th element in the list framework create another array of size 8, copy all 4 list elements from the old array to new array and then add new element to the new array. Now when we add 9th element framework creates and new array of size 16 and copy elements from older array to new array and add newly added element. This creation of new array and copying of older elements keep repeating whenever we reach the size of underline array. All this operation require time and operation and hits performance. It is a good idea to initialize a list with required capacity in advance, if we know how many Items we need to store in a list . So, if you know that you may have from, say, 50 to 60 items in your list, create a list with capacity 60 and no memory deallocation will happen and Garbage Collector will not have to clean up old arrays.

How to allow a very large object in .net application?

2018-07-28T14:59:00.000-07:00

Since .NET 1.0 the memory limit of .NET object is 2GB. This means you cannot for example create array which contains elements with more than 2GB in total. If try to create such array, you will get the OutOfMemoryException.
Let’s see an example how to produce OutOfMemoryException.

Before that Open Visual Studio, and create C# Console Application. Lets create simple struct with two double members like example below:

public struct ComplexNumber {
public double Re;
public double Im;

public ComplexNumber(double re, double im) {
Re = re;
Im = im;
}
}

As we know this structure consumes about 16 bytes of memory. So if we want to create array of this type which consume more than 2GB we need to create array at least with 134217728 instances. So this sample program below creates 130000000 (about 1,97 GB) of array.

int maxCount = 130000000;
ComplexNumber[] arr = null;
try {
arr = new ComplexNumber[maxCount];
} catch (Exception ex) {
Console.WriteLine(ex.Message);
}

So if we run this sample program the output will be like picture below:

Let’s try to create 140000000 instances. This is about 2.08 GB. The output produces exception:

The new feature of .NET 4.5 allows to create object beyond this magical number. To enable creation of object more than 2 GB, you only need to set proper variable in configuration file. The new gcAllowVeryLargeObjects
Element enables creation of array that are greater than 2 gigabytes (GB) in total size on 64 bit platform. So the following configuration file allows us to create more that 140000000 instances of our sample.

Now,If we run our sample the output is:

Ok how about to create more than 3GB of instances. For that propose, we need to create at least 201326592 instances. If we include this number in our sample the output is:

Be careful with this feature, because it will suck all your computer memory.

This feature works only with 64bit OS, it will not work with 32 bit.

Before you use this feature please see official description, because it contains some limitation which you must know before you use.

When to use Static Constructor?

2018-07-28T14:58:00.004-07:00

A static constructor is used to initialize any static data, or to perform a particular action that needs to be performed once only. It is called automatically before the first instance is created or any static members are referenced.

class SimpleClass
{
    // Static variable that must be initialized at run time. 
    static readonly long baseline;

    // Static constructor is called at most one time, before any 
    // instance constructor is invoked or member is accessed. 
    static SimpleClass()
    {
        baseline = DateTime.Now.Ticks;
    }
}

Static constructors have the following properties:

A static constructor does not take access modifiers or have parameters.
A static constructor is called automatically to initialize the class before the first instance is created or any static members are referenced.
A static constructor cannot be called directly.
The user has no control on when the static constructor is executed in the program.
A typical use of static constructors is when the class is using a log file and the constructor is used to write entries to this file.
Static constructors are also useful when creating wrapper classes for unmanaged code, when the constructor can call the LoadLibrary method.
If a static constructor throws an exception, the runtime will not invoke it a second time, and the type will remain uninitialized for the lifetime of the application domain in which your program is running.

In the example below, class Bus has a static constructor. When the first instance of Bus is created (bus1), the static constructor is invoked to initialize the class. The sample output verifies that the static constructor runs only one time, even though two instances of Bus are created, and that it runs before the instance constructor runs.

public class Bus
    {
        // Static variable used by all Bus instances. 
        // Represents the time the first bus of the day starts its route. 
        protected static readonly DateTime globalStartTime;

        // Property for the number of each bus. 
        protected int RouteNumber { get; set; }

        // Static constructor to initialize the static variable. 
        // It is invoked before the first instance constructor is run. 
        static Bus()
        {
            globalStartTime = DateTime.Now;

            // The following statement produces the first line of output,  
            // and the line occurs only once.
            Console.WriteLine("Static constructor sets global start time to {0}",
                globalStartTime.ToLongTimeString());
        }

        // Instance constructor. 
        public Bus(int routeNum)
        {
            RouteNumber = routeNum;
            Console.WriteLine("Bus #{0} is created.", RouteNumber);
        }

        // Instance method. 
        public void Drive()
        {
            TimeSpan elapsedTime = DateTime.Now - globalStartTime;

            // For demonstration purposes we treat milliseconds as minutes to simulate 
            // actual bus times. Do not do this in your actual bus schedule program!
            Console.WriteLine("{0} is starting its route {1:N2} minutes after global start time {2}.",
                                    this.RouteNumber,
                                    elapsedTime.TotalMilliseconds,
                                    globalStartTime.ToShortTimeString());
        }
    }

    class TestBus
    {
        static void Main()
        {
            // The creation of this instance activates the static constructor.
            Bus bus1 = new Bus(71);

            // Create a second bus.
            Bus bus2 = new Bus(72);

            // Send bus1 on its way.
            bus1.Drive();

            // Wait for bus2 to warm up.
            System.Threading.Thread.Sleep(25);

            // Send bus2 on its way.
            bus2.Drive();

            // Keep the console window open in debug mode.
            System.Console.WriteLine("Press any key to exit.");
            System.Console.ReadKey();
        }
    }
    /* Sample output:
        Static constructor sets global start time to 3:57:08 PM.
        Bus #71 is created.
        Bus #72 is created.
        71 is starting its route 6.00 minutes after global start time 3:57 PM.
        72 is starting its route 31.00 minutes after global start time 3:57 PM.      
   */

Create, Edit, Update Excel Sheets on Sever

2018-07-28T14:58:00.002-07:00

You need to have Microsoft Excel installed on you web server if you are using Microsoft.Office.Interop.Excel. But its not always possible to install Microsoft Excel on your web server.

There is a small library named EPPlus which you can use to create, edit and update excel sheets on server. its available on codeplex as well as on nuget

Here is the sample code to write a excel file on server

private void DumpExcel(DataTable tbl)
        {
            using (ExcelPackage pck = new ExcelPackage())
            {
                //Create the worksheet
                ExcelWorksheet ws = pck.Workbook.Worksheets.Add("Demo");

                //Load the datatable into the sheet, starting from cell A1. Print the column names on row 1
                ws.Cells["A1"].LoadFromDataTable(tbl, true);

                //Format the header for column 1-3
                using (ExcelRange rng = ws.Cells["A1:C1"])
                {
                    rng.Style.Font.Bold = true;
                    rng.Style.Fill.PatternType = ExcelFillStyle.Solid;                      //Set Pattern for the background to Solid
                    rng.Style.Fill.BackgroundColor.SetColor(Color.FromArgb(79, 129, 189));  //Set color to dark blue
                    rng.Style.Font.Color.SetColor(Color.White);
                }

                //Example how to Format Column 1 as numeric 
                using (ExcelRange col = ws.Cells[2, 1, 2 + tbl.Rows.Count, 1])
                {
                    col.Style.Numberformat.Format = "#,##0.00";
                    col.Style.HorizontalAlignment = ExcelHorizontalAlignment.Right;
                }

                //Write it back to the client
                Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
                Response.AddHeader("content-disposition", "attachment;  filename=ExcelDemo.xlsx");
                Response.BinaryWrite(pck.GetAsByteArray());
            }
        }

How to use Azure AD Authentication in web application

2018-07-28T14:57:00.001-07:00

When you want to use Azure Active Directory Authentication in your web application, you have two choices. One when you create your application that time itself you can provide the organization details and Visual Studio will do the rest of the work for you. In background Visual Studio will create application registration for your newly created application. Below image shows where you can provide your organization details when you create a new application in Visual Studio

When you click on change authentication option you will be asked to provide you azure account details as shown below.

When you click on the OK button. Visual Studio will do all the magic and it will create web application solution which will have all the configuration done already. You can simple build the application and run, you will be redirected to you organizations AD page where you need to provide your credentials and then you will be able to login to your application.

But in most of the cases you will have to add Azure Active Directory Authentication in the existing application. In that case you can use connected services dialog to configure Azure Active Directory using following steps

In Visual Studio, create or open an ASP.NET MVC project, or an ASP.NET Web API project.
From the Solution Explorer, right-click the Connected Services node, and, from the context menu, select Add Connected Services.
On the Connected Services page, select Authentication with Azure Active Directory.
On the Introduction page of the Configure Azure AD Authenticationwizard, select Next.
On the Single-Sign On page of the Configure Azure AD Authenticationwizard, select a domain from the Domain drop-down list. The list of domains contains all domains accessible by the accounts listed in the Account Settings dialog. As an alternative, you can enter a domain name if you don’t find the one you’re looking for, such as mydomain.onmicrosoft.com. You can choose the option to create an Azure Active Directory app or use the settings from an existing Azure Active Directory app. Select Next when done.
On the Directory Access page of the Configure Azure AD Authentication wizard, ensure that the Read directory data option is checked.
Select Finish to add the necessary configuration code and references to enable your project for Azure AD authentication. You can see the Active Directory domain on the Azure portal.
Visual Studio will display a What Happened article to show you how your project was modified. If you want to check that everything worked, open one of the modified configuration files and verify that the settings mentioned in the article are there.

If you want to do Azure Active Directory configuration in the existing application without using connected services dialog box you can refer another post (link) which explain it.

What is an in parameter in C#

2018-07-28T14:56:00.006-07:00

C# 7.2 adds the in keyword to complement the existing ref and out keywords when you write a method that passes arguments by reference. The in keyword specifies that you are passing the parameter by reference and the called method does not modify the value passed to it.

This addition provides a full vocabulary to express your design intent. Value types are copied when passed to a called method when you do not specify any of the following modifiers. Each of these modifiers specify that a value type is passed by reference, avoiding the copy. Each modifier expresses a different intent:

out: This method sets the value of the argument used as this parameter.
ref: This method may set the value of the argument used as this parameter.
in: This method does not modify the value of the argument used as this parameter.

When you add the in modifier to pass an argument by reference, you declare your design intent is to pass arguments by reference to avoid unnecessary copying. You do not intend to modify the object used as that argument. The following code shows an example of a method that calculates the distance between two points in 3D space.

private static double CalculateDistance(in Point3D point1, in Point3D point2)
{
double xDifference = point1.X – point2.X;
double yDifference = point1.Y – point2.Y;
double zDifference = point1.Z – point2.Z;

return Math.Sqrt(xDifference * xDifference + yDifference * yDifference + zDifference * zDifference);
}

The arguments are two structures that each contain three doubles. A double is 8 bytes, so each argument is 24 bytes. By specifying the in modifier, you pass 4-byte or 8-byte reference to those arguments, depending on the architecture of the machine. The difference in size is small, but it can quickly add up when your application calls this method in a tight loop using many different values.

The in modifier complements out and ref in other ways as well. You cannot create overloads of a method that differ only in the presence of in, out or ref. These new rules extend the same behavior that had always been defined for out and ref parameters.

The in modifier may be applied to any member that takes parameters: methods, delegates, lambdas, local functions, indexers, operators.

Unlike ref and out arguments, you may use literal values or constants for the argument to an inparameter. Also, unlike a ref or out parameter, you don’t need to apply the in modifier at the call site. The following code shows you two examples of calling the CalculateDistance method. The first uses two local variables passed by reference. The second includes a temporary variable created as part of the method call.

var distance = CalculateDistance(pt1, pt2);
var fromOrigin = CalculateDistance(pt1, new Point3D());

There are several ways in which the compiler ensures that the read-only nature of an inargument is enforced. First of all, the called method can’t directly assign to an in parameter. It can’t directly assign to any field of an in parameter. In addition, you cannot pass an inparameter to any method demanding the ref or out modifier. The compiler enforces that the inargument is a readonly variable. You can call any instance method that uses pass-by-value semantics. In those instances, a copy of the in parameter is created. Because the compiler can create a temporary variable for any in parameter, you can also specify default values for any in parameter. The follow code uses that to specify the origin (point 0,0) as the default value for the second point:

private static double CalculateDistance2(in Point3D point1, in Point3D point2 = default)
{
double xDifference = point1.X – point2.X;
double yDifference = point1.Y – point2.Y;
double zDifference = point1.Z – point2.Z;

return Math.Sqrt(xDifference * xDifference + yDifference * yDifference + zDifference * zDifference);
}

The in parameter designation can also be used with reference types or built in numeric values. However, the benefits in both cases are minimal, if any.

What is private protected access modifier

2018-07-28T14:56:00.004-07:00

Finally, with C# 7.2 we get a new compound access modifier: private protected indicates that a member may be accessed by derived classes that are declared in the same assembly. While protected internal allows access by derived classes or classes that are in the same assembly, private protected limits access to derived types declared in the same assembly
With this now we have following six accessibility levels that can be specified using the access modifiers:
public: Access is not restricted.
protected: Access is limited to the containing class or types derived from the containing class.
internal: Access is limited to the current assembly.
protected internal: Access is limited to the current assembly or types derived from the containing class.
private: Access is limited to the containing type.
private protected: Access is limited to the containing class or types derived from the containing class within the current assembly.

Stored procedure returns int instead of result set

2018-07-28T14:56:00.001-07:00

I had a Stored Procedure created in Azure Sql DB and wanted to use it in Entity Framework. Stored Procedures was returning a data set in Sql Server Management Studio but when updated my edmx file and tried to call it from C# code, it was returning a int instead of the result set I was expecting. I found number of users were facing this issue and most of the solutions on net were not working. After spending some 30 minutes I found the solution. In this post I will try to explain the solution steps by step.
Step 1: We need to add SET FMTONLY OFF; as first line of our stored procedure. It will help Entity Framework to find our the list of column Stored Procedure returns.
Step 2: Move to your .edmx and At Model Browser Window/Function Imports find your procedure then double click it. A window will open as shown below

Step 3: Change the return type to complex type and then click on generate complete type button. It will generate a class which will represent the return type of stored procedure.
Now we will be able to use the stored produce and it will return a a list of POCO class which was generated in step 3.