.NOY Framework

Accessing and using office components from .net framework is not trivial (god knows why).
There is a complex office API and some weird security configurations that need to be done.
After wasting a lot of time trying to create a simple file with a simple table, I decided to share with you the articles that helped me.

Accessing office components from c# are well described in this great article By Doctor Peter A. Bromberg.

But!!!! this is not sufficient. after executing this code you will bump into weird security exceptions.
Solving those issues are well described in this article by Sushmita Kumari

Have fun

When using a “Find” method in a generic List, there is a need to implement a Predicate(T) delegate that defines the conditions of the element to search for. a not good MSDN example can be found here. why not good? because usually we want to add extra parameters to the Predicate(T) delegate.
A good way of doing it is by using Anonymous Method as below:

ourList.Find(delegate(OurObject objectItem)
{
return objectItem.StringToFind == stringToCheck;
}
);
a good reference for Anonymous Method can be found here

BTW, this post was written with a great assistance of our Telephony team

In every system we design and develop, choosing the data structure that fits to our needs is one of the most important decisions we made. Data structures not only fits to our storage need, it also affects our system complexity and its performance.
Performance is a big word, when it refers to data structures, we usually discuss the worst-case sequence and according to that we determine it.
but, in some cases the worst-case happens infrequently, and in most cases (also the average case) our performance is extremely different then the worst-case.
This kind of analyses is being called Amortized Analysis. Amortized analysis refers to the average running time and not the worst case running time.

Fibonacci Heap is a great example for amortized analysis. a glance in the table below shows its advantages versus a linked list

(*) Amortized time

How we accomplish this?
Fibonacci Heap is heap data structure consisting of a forest of trees. Its implementation discussed in details in this Wikipedia article and also being demonstrated in .
The main idea of it, is keeping the level of trees in a way that in the average case we will have less operations to do. only once in a while we will merge the trees and organize them to a binomial heap (this operation is being called CONSOLIDATE). since we kept the level of the trees, the CONSOLIDATE operation will take O(log n) in the average case and only infrequently it will take O(n).
Also, in some cases we can control the phase of the worst case and force it to happen. it can help us to improve our system performance by forcing CONSOLIDATE operation during an off-peak.

The use of Fibonacci Heaps improves the asymptotic time of Dijkstra’s algorithm for computing shortest paths in a graph and Prim’s algorithm for computing a minimum spanning tree of a graph.

Maybe some day in the future, Microsoft or Sun will choose to add this fascinating data structure to there implemented collections.

usually, most of the manipulations that are being done with lists are sorting. therefore most of the .Net Framework solutions are for doing that. But what if we want to shuffle a list instead of sorting it?
well, I have bump into that problem while ago, and try to come up with the most elegant solution for doing it.

my first approach was using the existing .Net Framework solutions for sorting and manipulate them in a way to provide a shuffling solution.

so I did as follow:

I have created a RandomComparer who implements IComparer<int> with the following compare method:

public int Compare(int x, int y)
{
if (x == y) return 0;
else return random.Next(2) == 0 ? 1 : -1;
}

Then, I shuffled the list while using the RandomComparer I have created:

List<int> sortedList = GetSortedList();
List<int> shuffledList;
shuffledList = sortedList.Sort(RandomComparer.Instance);

Looks like an elegant solution? well, it has 2 problems:

1. performance - sorting a list takes in the worst case O(n lgn) while shuffling can take O(n)
2. after running this code in load test I have noticed that once in ~200 times, a System.ArgumentException is being thrown saying: “IComparer did not return zero when Array.Sort called x. CompareTo(x). x”.
   notice that the Compare method described above returns 0
   if(x == y). after investigating this I figure that in some cases there is 3 parameters comparison, and some times we get:
   a > b, b > c, c> a. which makes no sense…

So, the best way I come up with is a simple implementation of a shuffle method that picks a random value from the sorted list and add it to the shuffled list:

public List<int> Shuffle(List<int> sortedList)
{
List<int> shuffledList = new List<int>(sortedList.Count);
int count = sortedList.Count;
for (int i = 0; i < count; i++)
{
int j = random.Next(sortedList.Count);
shuffledList.Add(sortedList[j]);
sortedList.Remove(sortedList[j]);
}
return shuffledList;
}

notice that this solution takes in the worst case O(n)

Data types

in SQL Server, data types for representing date and time are datetime and smalldatetime.

Not like the variety of structures .NET Framework 2.0 and .NET Framework 3.0 where DateTime, TimeSpan, Calendar and other structures are being used for storing dates and time intervals, in SQL we can use only datetime and smalldatetime.

The difference between datetime and smalldatetime is the range of dates and the accuracy of minutes and seconds
- datetime: January 1, 1753 - December 31, 9999, with accuracy of one three-hundredth of a second
- smalldatetime: January 1, 1900 - June 6, 2079, with accuracy to the minute

So, let’s get started…

Converting datetime into string (nchar, nvarchar, char, varchar)

using the CONVERT method we can convert a datetime into other expression in lots of formats

samples:

Sample 1: get the date in U.S standard

Sample 2: get the date and time in ODBC canonical (with milliseconds) standard

Sample 3: get the time in hh:mi format

useful functions when dealing with datetime

GETDATE:
Returns the current system date and time in the SQL Server standard internal format for datetime values.

Syntax for GETDATE:
GETDATE ( )

Sample:

DATEADD:

Returns a new datetime value based on adding an interval to the specified date.

Syntax for DATEADD: DATEADD (datepart , number, date )

Sample:

DATEDIFF:

Returns the number of date and time boundaries crossed between two specified dates.

Syntax for DATEDIFF: DATEDIFF ( datepart , startdate , enddate )

Sample:

DATENAME:

Returns a character string representing the specified datepart of the specified date.

Syntax for DATENAME:
DATENAME ( datepart ,date )

Sample:

DATEPART:

Returns an integer that represents the specified datepart of the specified date.

Syntax for DATEPART:
DATEPART ( datepart , date )

Sample: