Jan 19, 2016

Using Fiddler to test Web API Rest Services and pass an array as parameter + Filtering

1. In Fiddler’s Composer tab, Select the "Parsed" tab.

2. In the same tab, Change GET to POST and enter the address of your Web.api controller (“http://yoursite.com/api/yourControllerName”).

3. Again, under the same tab, In the Request headers Text Box Area (The heading 'Request Headers' may not be visible), enter a JSON content type. “Content-Type: application/json; charset=utf-8″ (w/o the braces). 4. Again, under the same tab, Put your JSON string array (Input param) in the Request Body. e.g., ["aaa","bbbbb","cccccccc"].

5. Click on "Execute". it will hit the controller and you can debug.

To Filter the huge number of network communications recorded in the Fiddler

1. Click on the "Filters" tab, Select "Use Filters"

2. In the 1st drop down under the Hosts Heading, Select "Show Only Intranet Hosts", in the second drop down, select "Show only the following Hosts"

3. In the following text box enter: Enter the local url for e.g. "http://localhost:31314/", here, I was hosting the service in IISExpress.

Posted by

Dec 17, 2015

Fluent code in c sharp

In 2005, the object-oriented programming expert Martin Fowler published his essay on the ‘fluent interface’. He described an approach for building software with more readable code that could be more easily maintained by developers because it is easier to read, and discover how to use, than a traditional API that contains functions with a number of parameters. While the fluent interface might have been an idea ahead of its time when the technique was first published, one now sees terms employed to describe code, such as, “fluid coding”, “fluent style” and “fluent API”, which suggest its time has arrived.


In LINQ, the 'fluent' method syntax flows logically and intuitively, and allows them to be combined simply, because each method returns the appropriate type of object for the next. Can this fluent technique be extended as an API style to make it easier to develop C# team-based applications for enterprises?

Read about it here

A-Look-at-Fluent-APIs
Posted by

Dec 10, 2015

Compile your asp.net mvc Razor views into a separate dll

A "step-by-step" guide on how to compile your razor views into a separate dll. Good post about how to package your MVC razor views into a shared .NET assembly that you can use in multiple projects. In the past, I often had duplicated views / helpers in each project that was using ASP.NET MVC 3 w/Razor. This was getting to be a maintenance headache, so I looked around and saw Chris Van De Steeg’s post about how to actually accomplish this.
Pre-compiling-razor-views

Precompile-mvc-views

Detect-errors-of-asp-net-mvc-views

Posted by
Labels: , , ,

Dec 4, 2015

Web Designing : screen-patterns

http://designingwebinterfaces.com/designing-web-interfaces-12-screen-patterns

http://blogs.msdn.com/themes/blogs/generic/postlist.aspx?WeblogApp=infopath&PageIndex=3


Posted by

Nov 18, 2015

Asynchronous Programming with Async and Await (MSDN) + Extra

https://msdn.microsoft.com/library/hh191443.aspx

https://code.msdn.microsoft.com/Async-Sample-Example-from-9b9f505c


http://www.abhisheksur.com/2010/10/c-50-asynchronous-made-easy.html



(Excerpted from http://www.abhisheksur.com/2010/10/c-50-asynchronous-made-easy.html)



What is await ? 

According to Whitepaper published on the CTP, await keyword lets you to wait your program and lets the program to be declared as a continuation of all the existing awaits so that the compiler automatically waits for all other awaits to be finished until the program continues its execution. 
In other words, say you have invoked 3 asynchronous methods from your code an asynchronous block from your code, you would just write the way you would have written this synchronously with a single keyword await before the call. The call lets the compiler wait until the execution successfully completes. Just as shown below :  
async Task GetStringsFromUrlAsync(string url)
{
     WebClient client = new WebClient();
     return await client.DownloadStringTaskAsync(new Uri(url));
}

This involves the call to DownloadStringTaskAsync which is already implemented for WebClient. Now as you can see I have specified the await just before the call to Asyncrhonous method DownloadStringTaskAsync, it will keep the call on wait. 

Even though if I say use : 

async Task GetStringsFromUrlAsync(string url)
 {
      WebClient client = new WebClient();
      Task<string> modifieduri = client.DownloadStringTaskAsync(new Uri(url));
      string result = await modifieduri;
      return await client.DownloadStringTaskAsync(new Uri(result));
}

It means the second Task depends on the first one. So in this case the First DownloadStringTaskAsync will be called. This call actually returns Task(Task for any other operation) which you can keep on wait until it is finished using await keyword. So when you execute, the first call will block until the result is fetched and then it will take the string result and call the next one. 

Thus you can see how you can use await on Task variable to wait the object for completion without any implementation of custom callbacks, global objects etc.

What is async? 

Now, how to implement the asynchronous method? Hmm, async keyword can be placed just before the function call to make the method asynchronous. 

By specifying the async keyword against your method call, the compiler will automatically select your method to be asynchronous, which means it will move to the next line before returning the result in parallel until it finds an await. In the example I have provided theDownloadStringTaskAsync is actually an extension which specifies to be called with async.

Async method can return void, Task or Task based on what you need in your environment. But it is mostly preferable to return at least a Task object so that the caller can better handle the call. 

For any async method, you should put await before fetching the result, otherwise you might end up with blank/null result. await works with async to stop the further execution before finishing the other operations in context.
Posted by
Labels: , , , , ,

C# 6.0: Language features and its internals Part 1

Learn about the enhancements in both the CLR and IL in C# 6.0:
---------------------------------------------------------------------------------------
(excerpted from http://www.abhisheksur.com/2015/03/c-60-language-features-and-its.html)

The feature set which have been added / modified as part of C# 6.0 are:

 1. Auto Property Initializer
2. Expression bodied Function
3. Static Class Uses
4. String Interpolation
5. Null Conditional operators
6. Exception filters
7. nameof operator
8. Dictionary initializers
9. await in try / finally.
10. Parameterless constructor for struct
------------------------------------------------------------------------------------


Feature 1 :  Auto Property Initializer

Auto properties are not new to C#. It was there since C# 3.0. The auto properties does not require a backing field to be defined which was done automatically during compilation. So as a coder, you can get a ready-made property without writing much of code. As auto properties does not have backing field exposed, you cannot initialize the backing field during object initialization, rather you have to initialize explicitly in constructors.




    
public class AutoPropertyInitialier
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }

        public string FullName { get; set; }

        public AutoPropertyInitialier()
        {
            this.FirstName = "Abhishek";
            this.LastName = "Sur";

            this.FullName = this.FirstName + " " + this.LastName;
        }
    }
You can see in the above code block, the FirstName and LastName were Auto - Implemented properties, and both of them were initialized during constructor call, as the backing fields are not exposed for them. Think of a situation when your class is pretty big and you want to introduce a new property, you need to again initialize it inside constructor. This is the pain of the developer.

With C# 6.0, the initialization of auto-implemented properties is damn easy. Take a look into the code below :



    public class AutoPropertyInitializer
    {
        public string FirstName { get; set; } =  "Abhishek";
        public string LastName { get; } = "Sur";

        //public string FullName { get; } = this.FirstName + this.LastName;

        public string FullName { get; }

        public AutoPropertyInitializer()
        {
            this.FullName = this.FirstName + " " + this.LastName;
        }
    }

Here the properties FirstName and LastName were initialized directly after the declaration. You can notice the LastName were intentionally made readonly by not mentioning the setter. The backing field produced for a readonly property is also a readonly variable.

The FullName though is initialized inside constructor as the object initialization works before the constructor call, and hence initialization cannot evaluate "this".


In the above image, the C# representation of actual IL is shown which clearly indicates that the properties do have their backing fields. You can also notice the backing fields for property LastName is defined as readonly. The auto-property initialization is handled very cautiously during compilation and is abstract to you and relieves some of the pain points on writing un-necessary code. 
Feature 2 : Expression bodies functions 
Similar to Auto property initialization, C# 6.0 also comes up with expression bodies functions a long awaited feature. Expression bodied function is also a syntactic sugar implemented in the language which adds the flexibility on how you define member functions. 

Lambda expressions are not new to the language, but you might already know you cannot assign a lambda to a member function if the member function is not defined with a delegate. But if you read my internals to Lamba expression, you already know that for each lambda declaration the compiler creates a backing function body, but that function body cannot be exposed to class level. C# 6.0 enhances the language to allow you to define a member function with lambda expressions. 




    public class ExpressionBodiedFunction
    {
       
        public string WelcomeMsg(string name) => string.Format("Welcome {0}", name);

        public string HelloMsg => "Abhishek";

        public void Print() => Console.WriteLine(this.HelloMsg);

    }
In the above code block the WelcomeMsg is a member function that takes a string argument and returns a string. As per lambda rules, a lambda which has a return statement does not require a return keyword, hence the WelcomeMsg returns the expression with string.Format.

The second property is HelloMsg which is a property like method where the getter of the property HelloMsg will return the string "Abhishek". Remember, as property is also auto-implemented, the get keyword is also automatically evaluated by the compiler.

The last method "Print" is a void method and hence require a non-returning expression. The Console.WriteLine calls the property HelloMsg to print "Abhishek".

Now how does the compiler handles the lambda now without an explicit declaration of delegates ? Well, the answer is simple. The compiler re-writes the lambda into a full functional method body.


Here the WelcomeMsg, HelloMsg and Print after compilation is just a class level methods. The compiler entirely re-written the class into a strongly typed method bodies.


Feature 3 : Static class uses
The C# language teams identified the developers pain points very well, and implemented the Static class uses in the language. If you are using Static types it is always a nice to have feature in the language such that we can omit the repetitive static method call.

For instance, say I want to print a number of lines on screen, using Console.WriteLine. How about if we don't need to mention Console each line when we call WriteLine ? Static class uses does the same thing. Static class uses also recognize extension methods, hence if say a static class defines extension methods, if you add it, it will automatically recognize the extension methods as well.



    using static System.Console;
    using static System.Linq.Enumerable;

    public class UseStatic
    {
        public void CallMe()
        {

            WriteLine("Hi");

            var range = Range(10, 10);
            var check = range.Where(e => e > 13);
            // Static extension method can 
            // only be called with fulll representation
        }
    }


In the above code the WriteLine is automatically detected as we added the head using static statement. The Range is also declared inside System.Linq.Enumerable which is automatically determined and Where is an extension function. The static uses automatically recognized the extension methods as well.

If you look at the internals of the static uses, the compiler rewrites the static type calls on every occurrences of its method call.


In the actual IL, you can see, the WriteLine is padded with its appropriate type Console and Range is also associated with Enumerable. The re-writing is done by the compiler.

Feature 4 : String Interpolation 

String interpolation is another interesting feature introduced with recent version of C# 6.0. Interpolation is not new with strings. We can do string interpolation using string.Format before, but the problem is the code looks really ugly when using interpolation constructs.

For instance,


string myString = "FullName :" + p.First + " " + p.Last;
string myString = string.Format("FullName : {0} {1}", p.First, p.Last);
Here the first instance, is normal string concatenation. This creates an issue with multiple memory allocation if not string interned. The second statement uses string.Format to format a given string and replaces the {} arguments with the proper arguments as parameter to the method. Now while dealing with multiple occurrences of these kind of string placeholders might look very ugly and un-maintainable and error prone.

C# 6.0 comes with a new technique where the string interpolation can take place in between the strings, or rather than putting numeric placeholders, you can use the actual values.



string myString = $"FullName : {p.First, 5} {p.Last, 20}";
Console.WriteLine(myString);

string my2ndString = $"FullName from EBF = {this.EBF.FullName}";
Console.WriteLine(my2ndString);

Here Feature 4 :the string need to be started with a $ sign which indicates that the new kind of string interpolation to occur. The {p.First, 5} will be replaced with the value of p.First aligned to 5 characters.

Now what does the compiler do when these kind of interpolation is encountered. Well, you might be surprised to see, that the string is actually replaced by a call of String.Format during compilation.


So here you can see the actual statement after compilation is nothing but a string.Format call. So string interpolation is also a compiler trick. 
Feature 5 : Null conditional operators

Getting into NullReferenceException or "Object reference not set to instance of an object" is one of the most common exception that every developer must see while working with the langauge. It has been a common problem where developers need to give extra stress to check the null value before calling any member functions. Null for compiler is unknown, and hence if you call a method on null, it will point nowhere and hence throws NullReferenceException and exists the stack.

To handle nulls Microsoft had introduced few language constructs already like Null coalesce operator (??) or Conditional operators. But with the new feature introduced in C# 6.0, the language team has introduced another operator which checks for null.

Null Conditional operator is a new construct that gives away a shortcut to condition the null check before calling its members.



string zipcode = (address == null? null : address.zipcode);

string zipcode = (person == null? null : (person.address == null ? null : person.address.zipcode))

Here in the above two lines you can see how the complexity rises when there are multiple number of null checking on an expression. In the first statement the address is checked with null and when it has address, it will only then evaluate the zipcode. On the second statement, the person object is checked with null, then its address and then finally the zipcode is evaluated.

With null conditional operator the code would look like :



string zipcode = address?.zipcode;

string zipcode = person?.address?.zipcode;

Here the code is reduced greatly even though the actual expression logic remains the same. The ? mark is used for null conditioning. Null conditional operators does not exists as well, it is the same representation as that of the previous conditional operators. If you try to look into reflector, you will see it like :



You can see the null conditional operators are replaced by the compiler with normal conditional statements.

Feature 6 : Exception Filters

Now after so many syntactic sugar introduced with latest version of C#, this is the only new feature that directly relates to IL (Intermediate Language). From the very inception, the exception filters were there in CLR but was not exposed to the C# language. With C# 6.0, the exception filters finally came into existence and finally as a C# developer you can make use of it.

In C# the exception block contains try/catch/finally with multiple catch blocks supported. Based on type of the exception that has been encountered during runtime, the runtime chooses the appropriate catch block to execute. Exception filters allows you to filter out the catch blocks to ensure which catch block can handle the exception. With exception filters in place, there could be multiple catch blocks with same type where the type determines which filter it will call first.

Let us take a look at the code :



public class ExceptionFilters
    {
        public static bool LogException(Exception ex)
        {
            //Log
            return false;
        }
        public static bool LogAgainException(Exception ex)
        {
            //Log
            return true;
        }
        public void CallMe()
        {
            try
            {
                throw new ArgumentException("Exception");
            }
            catch (Exception ex) when (LogException(ex))
            {
                //Keep exception stack intact
            }
            catch(Exception ex) when (LogAgainException(ex))
            {
                // Calling the catch
            }
            
        }
    }

Here the ArgumentException is thrown when CallMe is invoked. The Exception filters are specified using when keyword just like in VB.NET. So the execution is like, it will call LogException method, executes the code and see whether the return statement is true or false. If it is true, it executes the catch block and exit, or otherwise it move and call LogAgainException method.

The exception filter expects a boolean value, hence the call to LogException should be a method returning bool or otherwise we need a comparison operator to always evaluate the when statement to boolean. Exception filters allows the developer to run arbitary code between the exception and the catch block execution without interfering the original stack trace of the exception object.

I have already told you that exception filters is a CLR concept. The IL is laid out as :


 .try --- to --- filter --- handler --- to ---

This tells the compiler to execute try block from line no --- to line ----. It will then call filter line and then call the handler which executes some bunch of lines. Cool ? Yes.

One small addition that I would want to add, if an exception filter encounters an exception and is left unhandled, the compiler handles it for you and automatically skip the exception block and moves to the next catch block. For instance if LogException in the code above throws an exception, it will call LogAgainException without modifying the Stack for ex.

Feature 7 : nameof Operator

nameof is a new addition to operator list supported by C#. This new operator is nothing but a compiler trick, where the compiler determines the name of a Property, Function or an Extension method and writes it directly in compiled output. For instance,



string name1 = nameof(this.MyProp); // evaluates MyProp
string name2 = nameof(DateTime.Now);//evaluates Now
string name3 = nameof(Console.WriteLine); //evaluates WriteLine
string name4 = nameof(new List<string>().FirstOrDefault); // Evaluates FirstOrDefault

string name5 = nameof(name4);//Evaluates name4

The nameof operator works on any type where the type has a name. In case you specify a variable, the nameof operator will evaluate to the name of the variable.





Feature 8 : Dictionary initializers



Dictionary is one of the common array object which used often to send data between objects. Unlike arrays, Dictionaries form an array of KeyValuePair. In modern days, Dictionary is used interchangeably with arrays because of its flexibility of defining key value set.












var list = new List<string>();
list.Add("Abhishek");
list.Add("Abhijit");

//Access
var first = list[0];
var second = list[1];






Here you can see a list is used to store string data, where index giving you the reference to individual objects. If I write the same with dictionary, it will look like :












var dict = new Dictionary<int,string>();
dict.Add(0, "Abhishek");
dict.Add(1, "Abhijit");

//Access
var first = dict[0];
var second = dict[1];






Even though the basics remain the same, the developers are increasingly inclined to use the later as it gives a flexibility to assign any index. You can define "Abhishek" to 10 and "Abhijit" to 20 without the limitation of fixed incremental index usage of dictionary.



As more and more people are going to Dictionary, language team thought about giving easier constructs to define Dictionary. Even though we can go without it, but it is a nice to have feature. In C# 6.0, you can define dictionary using the following syntax :










var dict = new Dictionary<int,string>
{
   [10] = "Abhishek",
   [20] = "Abhijit"
};

//Access
var first = dict[10];
var second = dict[20];






Or even if the key is declared as string, you can also use like:










var dict = new Dictionary<string,string>
{
   ["first"] = "Abhishek",
   ["second"] = "Abhijit"
};

//Access
var first = dict["first"];
var second = dict["second"];






This way it is very easier to declare and use dictionaries. The last two syntaxes were introduced in C# 6.0.



Now if you think of the actual implementation, there is nothing as such. If you try to sneak peek on the compiled code, you will be seeing the same code with object being initialized inside the constructor.













Here even though the new construct is used, the dictionary object is actually initialized in constructor itself. The code is re-written by the compiler.





Feature 9: Await in catch and finally



If you are not using async / await stuffs too often you might have already overlooked that you cannot specify await in catch or finally block before the latest version of C#. Microsoft has initially thought that it wont be possible to allow awaits in catch/finally because the compiler creates a state machine which slices each and every await statements into a sequence of calls which can pause and resume the function upon request. But as try/catch/finally are handled by CLR, allowing such thing will indicate every errors in the state machine is properly handled and also each of try/catch/finally would need their individual state machines each.



Based on the complexity, microsoft haven't provided the feature in previous version, but as everything is handled by the compiler itself, it is a very important feature to have as a programmers perspective hence in latest version of C# 6.0, the feature have been revised and await in catch/finally is allowed.












 public async Task<string> DownloadUrl(string url)
        {
            WebClient client = new WebClient();
            client.BaseAddress = "www.abhisheksur.com";
            try
            {
                return await client.DownloadStringTaskAsync(url);
            }
            catch
            {
                return await client.DownloadStringTaskAsync("mvp");
            }
            finally
            {
                //Await is also allowed.
            }
        }






Hence you can successfully compile the code above where the await works during the catch execution.



If you try looking at the code in reflector it will look very ugly with so many of StateMachine declarations and so many of goto statements to properly navigate to lines inside the state machine on failure. It would be nice if you can look into it personally, but if there is any problem understanding the implementation, feel free to ask me in discussions.



But as a benefit, you get this feature ready.





Feature 10: Parameterless constructor for struct



If you are unaware, there was no parameterless constructors in struct.  This is because of the fact that ValueTypes has a unique behavior where it will be automatically assigned a default memory when declared.



For instance,










int x;






Here int is a struct (System.Int32) and the value of x would be automatically 0. You can even declare array of a struct. For instance,












struct MyStruct
{
  public int Property1{get;set;}
  public string Property2 {get; set;}
}

MyStruct[] array = new MyStruct[10];






Now the Struct MyStruct will automatically get the default(MyStruct) in the array even though its not explicitly constructed. If you want to know more why struct does not support default constructor, feel free to read the article I posted
.



In C# 6.0 the parameterless constructor is allowed. This is also a trick made by the compiler. It actually replaces the default constructor with the parameterless constructor passed in when the new operator is used to construct the object.



So if you say,










MyStruct s = new MyStruct();






The .NET will call the parameterless constructor for you.









Posted by
































          

        

          

        

Apr 14, 2015


          

        







How to hard reset Visual Studio instance














When developing extensions sometimes you just mess up, others someone else does. If you start getting errors loading even the most mundane extensions, these are the instructions to hard reset your instance.



1. Close Visual Studio (if you haven’t already).



2. Open the registry editor (regedit.exe)



3. Delete the HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\{version}



4. Delete the HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\{version}_Config



5. Delete the %USERNAME%\AppData\Local\Microsoft\VisualStudio\{version} directory.


    

  • Enjoy your brand new Visual Studio instance.
    • 




Use {version}=10.0 for Visual Studio 2010
Use {version}=11.0 for Visual Studio 2012
Use {version}=12.0 for Visual Studio 2013



If on the other side you want to reset the experimental hive you can do the same to with the ‘{version}Exp’ ones.







(source: http://www.corvalius.com/site/hacks/how-to-hard-reset-visual-studio-instance/)











Posted by
































          

        

          

        

Apr 4, 2015


          

        







Connect to a SQL Server DB which is on a client Network while you are using your office PC 












Trusted Authentication will use the credentials that you are logged into the machine
with to try and connect, there’s not a way round this, if you want to use
trusted authentication for management studio, you need to be logged on to your
machine with an account that is allowed access to SQL, if not then you will
have to use SQL authentication.





Try this: Use RUNAS to set your Windows Auth domain for database connections




runas /user:domain\user "C:\Program Files\Microsoft SQL Server\90\Tools\Binn\VSShell\Common7\IDE\ssmsee.exe" 




runas /user:domain\user "C:\WINDOWS\system32\mmc.exe /s \'C:\Program Files\Microsoft SQL Server\80\Tools\BINN\SQL Server Enterprise
Manager.MSC\'"




runas /user:domain\user isqlw












Example:



runas /netonly /user:cricket\mdatta " C:\Program Files (x86)\Microsoft SQL Server\100\Tools\Binn\VSShell\Common7\IDE\ssms.exe"




runas /netonly /user:cricket\mdatta isqlw










Posted by
































          

        

          

        

May 27, 2014


          

        







Oracle Data Access blues: 64 bit ODAC






















Posted by
































          

        

          

        

Mar 3, 2014


          

        







MS Outlook --> Power point Presentation in attachment--> quick preview --> Mouse cursor dissappears  












Recently, I was facing this nagging issue pretty often.

A brief description of the problem:



When you try to do a quick preview of a Powerpoint presentation that came to you by mail, what happens quite often is that post the presentation, the mouse cursor dissappears.







There are many suggested ways to tide over this problem.



I have discovered a easy way out of it. In case this happens, just click on the ppt once more for another quick preview, and voila the cursor will reappear!!! 











Posted by

















Labels:























Oracle.DataAccess.dll version mismatch...
















In a recent project I was faced with this problem:

I had compiled a local asp.net mvc project pointed to my installed version of the Oracle.ataaccess.dll (from the GAC). Instead of a complete project deployment, I was supposed to just replace the main project dll in the server.



Upon deployment, I found that the version of the Oracle.Dataaccess.dll was not the same and i was getting a "Version Mismatch error", whenever there was a call from the site to the Oracle DB. The Ora Client version in my dev box was 12.1.1.0. 

To add to it, the environments of the Dev and the Web server were also different. My local dev box was a 32bit Win 7 whereas the webserver was a 64bit Win Server 2008 R2.



So the first challenge was to know what is the installed version of the Oraclient in Server.

I could not locate the Oracle Client in the usual place on the server, i.e., C://Oraclient/Products/.

1. So I opened the Environment Variables of the server and from the Path Variable found the path to the Oraclient.

From there I got the Oraclient version.

2.  I opened the GAC of the machine to confirm the version

3. I downloaded the exsiting dll of the mvc project and dissembled it (using ILSpy) to see the referenced Oracle version.



I found that the used version on the server was 11.2.3.0

----------------------

Now that I know of the 2 versions, the next challenge was to fix the mismatch of the versions.

The first thing which came to my mind was to uninstall the local version, download and install the one on the server, recompile and the replace the dll.

But that was a cumbersome process, and I couldn't find the exact oraclient version on the net too.

So, I investigated aa little more... From the experience of a previous project, i knew that in the web.config we can instrument the assembly which we want to be loaded.



Then I found this website with the steps: it was not an exact same scenario, but quite close.

(http://tiredblogger.wordpress.com/2008/11/06/getting-oracledataaccess-working-on-x64/)



taking a cue from the website I added the following section to my web.config









<dependentAssembly>
       <assemblyIdentity name="Oracle.DataAccess" publicKeyToken="89b483f429c47342"/>
       <bindingRedirect oldVersion="0.0.0.0-4.121.1.0" newVersion="4.112.3.0"/>
</dependentAssembly>








and voila, after the deployment of the new dll, it was working fine....



ohh and BTW, I got the public key token of the installed oraclient version from the dissembled dll.

















Posted by

















Labels:
















          

        

          

        

Feb 11, 2014


          

        







What NOT to do in ASP.NET


















Excerpted from Scott Hanselman's blog. 



A must read for all web programmers...



(Original source: http://www.hanselman.com/blog/ChecklistWhatNOTToDoInASPNET.aspx)



----------------------------------------------------------------------------------------




















Posted by

















Labels:
,
















          

        

          

        

Sep 5, 2013


          

        







ASP.Net MVC alternative means of authentication



















Posted by

















Labels:
,
,
,
,
















          

        

          

        

Sep 4, 2013


          

        






















Posted by

















Labels:
















          

        

          

        

Aug 30, 2013


          

        







Silverlight + WCF : Polling Duplex Examples



















Posted by

















Labels:
,






















Great Tech Blogs











  
 Sl
Blog Url
Description
 


 
  1
  Ido Flatows Blog http://feeds.feedburner.com/IdoFlatowsBlog
  Area of expertise: WCF, Azure, IIS, IIS Perf (http://feedproxy.google.com/~r/IdoFlatowsBlog/~3/qiMlWjxYP1I/fixing-iis-advanced-logging-performance-counters-errors.aspx)


 

 
2      
 
 3      
 

 4      
 
 5      
 
 6      
 
 7      
 
 8      
 
 9      
 
 10      
  








Posted by

















Labels:
















          

        

          

        

Jul 3, 2013


          

        







A Visual Explanation of SQL Joins












http://www.codinghorror.com/blog/2007/10/a-visual-explanation-of-sql-joins.html



Sql Joins and Venn Diagrams..

A very interesting read










Posted by






































How to loop in Sql Server











Scenario: We have a Table : TableA
 
Structure of TableA:
 
Id                Name
 
 -- ---------------------------
 
 1           Pirate 
 
2            Monkey 
 
3            Ninja 
 
4            Spaghetti
 
-------------------------------
 
 
 
Requirement: Iterate through the Names (“Name” column) of TableA
 
Solution:
 
We all know that the most convenient, easy and widely used solution is by using a Cursor. 
 
DECLARE cursor1 CURSOR 
 
         FOR SELECT Name FROM TableA 
 
 OPEN cursor1 
 
       FETCH NEXT FROM cursor1
 
This works, but we should be aware of the disadvantages of using a Cursor… 
 
Cursor implementation in application, helps data manipulation easy and even they are very effective but due to some major disadvantage of Cursor normally they are not preferred. 
 
Disadvantages of cursors 
     
  • Uses more resources because Each time you fetch a row from the cursor, it results in a network roundtrip  
  • There are restrictions on the SELECT statements that can be used.  
  • Because of the round trips, performance and speed is slow.
    •  
  • As we know cursor doing round trip it will make network line busy and also make time consuming methods. First of all select queries generate output and after that cursor goes one by one so round trip happen. 
    •  
  • Another disadvantage of cursor are there are too costly because they require lot of resources and temporary storage so network is quite busy.
 
Apart from these I would like to point out some great advantages of cursor if the entire result set must be transferred to the client for processing and display.
 
     
  • Client-side memory : For large results, holding the entire result set on the client can lead to demanding memory requirements on client side system.
    •  
  • Response time : Cursors can provide the first few rows before the whole result set is assembled. If you do not use cursors, the entire result set must be delivered before any rows are displayed by your application.
    •  
  • Concurrency control :It's a general problem with current applications, If you make updates to your data and do not using cursors in your application, you must send separate SQL statements to the database server to apply the changes. This raises the possibility of concurrency problems if the result set has changed since it was queried by the client. In turn, this raises the possibility of lost updates.But Cursors act as pointers to the underlying data, and so impose proper concurrency constraints on any changes you make.
 
Some Alternatives to using a Cursor:
 
     
  • Use WHILE LOOPS  
  • Use temp tables  
  • Use derived tables  
  • Use correlated sub-queries  
  • Use the CASE statement  
  • Perform multiple queries 
 
It has been generally observed that looping without using a cursor is faster than looping using a cursor.
 
Some solutions:
 
1.  Add the recordset to a new Temp Table and also introduce a new column to the temp table. 
 
*****************************************************
set rowcount 0
select NULL mykey, * into #mytemp from TableA
 
set rowcount 1
update #mytemp set mykey = 1
 
while @@rowcount > 0
begin
set rowcount 0
select * from #mytemp where mykey = 1
delete #mytemp where mykey = 1
set rowcount 1
update #mytemp set mykey = 1
end
set rowcount 0
 
*****************************************************************
 
2.  The following solution assumes that there is a unique indexed int column named id.
 
declare @id char( 11 )
 
select @id = min( id ) from TableA
 
while @id is not null
begin
    select * from TableA where id = @id
    select @id = min( id ) from TableA where id > @id
end
 
****************************************************************
 
3.  Here to the temp table we are adding a new column (RowID ) which is a identity column
 
DECLARE @RowsToProcess  int
DECLARE @CurrentRow     int
DECLARE @SelectCol1     int
 
DECLARE @table1 TABLE (RowID int not null primary key identity(1,1), Name varchar(50))  
INSERT into @table1 (Name ) SELECT Name FROM tableA
SET @RowsToProcess=@@ROWCOUNT
 
SET @CurrentRow=0
WHILE @CurrentRow<@RowsToProcess
BEGIN
    SET @CurrentRow=@CurrentRow+1
    SELECT 
        @SelectCol1=Name 
        FROM @table1
        WHERE RowID=@CurrentRow
 
    --do your thing here--
 
END
 
 
 
******************************************************************
 
4.
 
DECLARE @table1 TABLE (
    idx int identity(1,1),
    col1 int )
 
DECLARE @counter int
 
SET @counter = 1
 
WHILE(@counter < SELECT MAX(idx) FROM @table1)
BEGIN
    DECLARE @colVar INT
 
    SELECT @colVar = col1 FROM @table1 WHERE idx = @counter
 
    -- Do your work here
 
    SET @counter = @counter + 1
END
 
 
 
Believe it or not, this is actually more efficient and performant than using a cursor.
 
*********************************************************************
 
5. 
 
DECLARE
  @LoopId  int
 ,@MyData  varchar(100)
 
DECLARE @CheckThese TABLE
 (
   LoopId  int  not null  identity(1,1)
  ,MyData  varchar(100)  not null
 )
 

INSERT @CheckThese (YourData)
 select MyData from MyTable
 order by DoesItMatter
 
SET @LoopId = @@rowcount
 
WHILE @LoopId > 0
 BEGIN
    SELECT @MyData = MyData
     from @CheckThese
     where LoopId = @LoopId
 
    --  Do whatever
 
    SET @LoopId = @LoopId - 1
 END
 
*********************************************************************
 
6. 
 
*********************************************************************
 
While fetching we should always remember that SQL Server Queries are SET Based operations and work best in circumstances dealing with SET Based operations. 
 
You can loop through the table variable or you can cursor through it. This is what we usually call a RBAR - pronounced Reebar and means Row-By-Agonizing-Row. 
So, we should always strive to find a SET-BASED answer and move away from RBARs as much as possible. 
Set based queries are (usually) faster because: 
     
  1. They have more information for the query optimizer to optimize  
  2. They can batch reads from disk  
  3. There's less logging involved for rollbacks, transaction logs, etc.  
  4. Less locks are taken, which decreases overhead  
  5. Set based logic is the focus of RDBMSs, so they've been heavily optimized for it (often, at the expense of procedural performance)
  








Posted by

















Labels:
,
,
,
,
,
















          

        

          

        

Jul 2, 2013


          

        







Popular Javascript Frameworks











  
Knockout.js
 
Knockout is a JavaScript library that helps you to create rich, responsive display and editor user interfaces with a clean underlying data model. Any time you have sections of UI that update dynamically (e.g., changing depending on the user’s actions or when an external data source changes), KO can help you implement it more simply and maintain-ably. 
http://knockoutjs.com/ 
Knockout.js 
  
Angular.js
 
AngularJS is an open-source JavaScript framework, maintained by Google, that assists with running what are known as single-page applications. Its goal is to augment browser-based applications with model–view–controller (MVC) capability, in an effort to make both development and testing easier. The library reads in HTML that contains additional custom tag attributes; it then obeys the directives in those custom attributes, and binds input or output parts of the page to a model represented by standard JavaScript variables. The values of those JavaScript variables can be manually set, or retrieved from static or dynamic JSON resources.
http://angularjs.org/
Angular.js 
  
Backbone.js
 
Backbone.js gives structure to web applications by providing models with key-value binding and custom events, collections with a rich API of enumerable functions, views with declarative event handling, and connects it all to your existing API over a RESTful JSON interface.
http://backbonejs.org
Backbone.js 
  
Node.js
 
Node.js is a platform built on Chrome’s JavaScript runtime for easily building fast, scalable network applications. Node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient, perfect for data-intensive real-time applications that run across distributed devices.
http://nodejs.org/
Node.js 
  
Modernizr
 
Modernizr is a small JavaScript library that detects the availability of native implementations for next-generation web technologies, i.e. features that stem from the HTML5 and CSS3 specifications. Many of these features are already implemented in at least one major browser (most of them in two or more), and what Modernizr does is, very simply, tell you whether the current browser has this feature natively implemented or not.
http://modernizr.com
Modernizr 
  
Require.js
 
RequireJS is a JavaScript file and module loader. It is optimized for in-browser use, but it can be used in other JavaScript environments, like Rhino and Node. Using a modular script loader like RequireJS will improve the speed and quality of your code.
http://requirejs.org
Require.js 
  
Less
 
LESS extends CSS with dynamic behaviour such as variables, mixins, operations and functions.LESS runs on both the server-side (with Node.js and Rhino) or client-side (modern browsers only).
http://lesscss.org/
Less 
  
Sass
 
Sass is an extension of CSS3, adding nested rules, variables, mixins, selector inheritance, and more. It’s translated to well-formatted, standard CSS using the command line tool or a web-framework plugin.
http://sass-lang.com
Saas 
 
 
Source: http://www.codeproject.com/Articles/596800/JavaScript-Frameworks-and-Resources
  








Posted by

















Labels:
,
,
















          

        

          

        

Jan 30, 2013


          

        







 Dynamic Dictionaries with C# 4.0












source: http://www.aaron-powell.com/dynamic-dictionaries-with-csharp-4





Have you ever been working with the Dictionary object in .NET and just wanted to find some way in which you can do this:










  var dictionary = new Dictionary { { "hello", "world!" } };

  ...

  var something = dictionary.hello;










It'd be sweet, but it's not possible. The dictionary is just a bucket and there isn't a way it can know at compile type about the objects which are within it. Damn, so you just have to go via the indexer of the dictionary.







But really, using dot-notation could be really cool!







Well with the .NET 4.0 framework we now have a built in DLR so can we use the dynamic features of the C# 4 to this?



Introducing the DynamicObject







Well the answer is yes, yes you can do this, and it's really bloody easy, in fact you can do it in about 10 lines of code (if you leave out error checking and don't count curly braces :P).







First off you need to have a look at the DynamicObject which is in System.Runtime. There's a lot of different things you can do with the DynamicObject class, and things which you can change. For this we are going to work with TryGetMember, with this we just need to override the base implementation so we can add our own dot-notation handler!







So lets start with a class:












using System;

using System.Collections.Generic;

using System.Dynamic;



namespace AaronPowell.Dynamics.Collections

{

  public class DynamicDictionary : DynamicObject

   {

     private IDictionary dictionary;


     public DynamicDictionary(IDictionary dictionary)

      {

         this.dictionary = dictionary;

       }

   }

}











Essentially this is just going to be a wrapper for our dynamic implementation of a dictionary. So we're actually making a class which has a private property which takes a dictionary instance into the constructor.







Now we've got our object we need do some work to get it handle our dot-notation interaction. First we'll override the base implementation:







public override bool TryGetMember(GetMemberBinder binder, out object result)

{

   var key = binder.Name;

   if (dictionary.ContainsKey(key))

   {

     result = dictionary[key];

     return true;

   }

   throw new KeyNotFoundException(string.Format("Key \"{0}\" was not found in the given dictionary", key));

}









And you know what, we're actually done! Now all you have to do:












var dictionary = new Dictionary {{ "hello", "world!" }};

dynamic dynamicDictionary = new DyanmicDictionary(dictionary);

Console.WriteLine(dynamicDictionary.hello); //prints 'world'








I'm going to be releasing the source for this shortly (well, an improved version), along with a few other nifty uses for dynamic. So keep watching this space for that ;).







----------------------------------------------------------



By overriding the TryGetMember and TrySetMember method you can dynamically add and remove properties.









dynamic person = new DynamicClass; person.Name = “John Smith”; person.Phone = “32345690″;







By overriding the TrySetIndex and TryGetIndex you can access properties you don’t know about at compile time. dynamic person = new DynamicClass; person["Name"] = “John Smith”;







and then both are interchangable











public class DynamicDictionary : DynamicObject 
{ 
 
  private Dictionary _dictionary = new Dictionary();

  public override bool TryGetMember(GetMemberBinder binder, out object result)

  {

    return _dictionary.TryGetValue(binder.Name, out result);

  }


  public override bool TrySetMember(SetMemberBinder binder, object value)
  {

    _dictionary[binder.Name] = value;

    return true;

  }


  public override bool TrySetIndex(SetIndexBinder binder, object[] indexes, object value)

  {

    if (dictionary.ContainsKey((string)indexes[0]))

       _dictionary[(string)indexes[0]] = value;

    else

      _dictionary.Add((string)indexes[0], value);

    return true;

  }


public override bool TryGetIndex(GetIndexBinder binder, object[] indexes, out object result)
  {

    return _dictionary.TryGetValue((string)indexes[0], out result);

  }

} 








} 



Umbraco







While we were working on some sexy features for Umbraco 5 over the CodeGarden 10 retreat we kept saying that we should look at using as many of the cool new .NET framework features which we can possibly get away with. To this extent we kept saying we need to work out how to implement the dynamic keyword in some way.







Well that's where the idea for the above code came from, in fact we've got a similar piece of code which will be usable within the framework of Umbraco 5 and entity design. But the full info on that will belong to another post ;).



Released!







I've rolled the above code (with some improvements mind you) into a new project that I've been working on for making working with dynamics in .NET a whole lot easier. You can check out my Dynamics Library and get dynamacising.











Posted by
































        

      









Subscribe to:
Posts (Atom)