http://localhost:4303/Default.aspxtry
http://localhost.:4303/Default.aspxThere is also one option in Fiddler which can cause problems and has to be turned off So in Fiddler goto Tools --> Fiddler Options -->General Tab --> Uncheck "Enable IPv6 (if available)"
ASP.NET Web Part controls are an integrated set of controls for creating Web sites that enable end users to modify the content, appearance, and behavior of Web pages directly in a browser.Excel Services is part of Microsoft Office SharePoint Server 2007 which is built on ASP.NET and Windows SharePoint 3.0 technologies. Using Excel Web Services we can create Web Parts which can be dropped into SharePoint and add custom functionality into it. More Here Using Excel Web Services in a SharePoint Web Part
ddlWeekDays.DataSource = Enum.GetNames(typeof(EnumWeekDays)); ddlWeekDays.DataBind(); HtmlControl myCodeBehindAcceddToIFrame = (HtmlContrl)this.FindControl(myIFrame); myCodeBehindAcceddToIFrame.Attributes["src"] = "…new url..."
//Compile-Time constant
public const int Pi=3.14;
//Run-Time constant
public static readonly float Pi=3.14;
We can write custom handlers to override these events
class Program
{
static void Main(string[] args)
{
// Setup Chain of Responsibility
Employee h1 = new Programmer();
Employee h2 = new Manager();
Employee h3 = new CEO();
h1.SetBoss(h2);
h2.SetBoss(h3);
// Generate and process request
int[] inquiries = { 1, 2, 3, 3, 2, 4, 1, 1 };
foreach (int inquiry in inquiries)
{
h1.Approve(inquiry);
}
// Wait for user
Console.Read();
}
}
abstract class Employee
{
protected Employee Boss;
public void SetBoss(Employee boss)
{
this.Boss = boss;
}
public abstract void Approve(int inquiry);
}
class Programmer : Employee
{
public override void Approve(int inquiry)
{
if (inquiry <= 1)
{
Console.WriteLine("Inquiry approved by the employee");
}
else if (Boss != null)
{
Boss.Approve(inquiry);
}
}
}
class Manager : Employee
{
public override void Approve(int inquiry)
{
if (inquiry <= 2)
{
Console.WriteLine("Inquiry approved by the manager");
}
else if (Boss != null)
{
Boss.Approve(inquiry);
}
}
}
class CEO : Employee
{
public override void Approve(int inquiry)
{
Console.WriteLine("Inquiry approved by the CEO");
}
}
class Program
{
static void Main(string[] args)
{
//The client has no idea about the older code
Target target = new Adapter();
target.NewerMethod();
}
}
class Target
{
public virtual void NewerMethod()
{
Console.WriteLine("Called Target-NewerMethod");
}
}
// The actual "Adapter"
class Adapter : Target
{
//Points to the older piece of code
private Adaptee adaptee = new Adaptee();
public override void NewerMethod()
{
adaptee.OlderMethod();
}
}
// "Adaptee"
class Adaptee
{
public void OlderMethod()
{
Console.WriteLine("Called OlderMethod");
}
}Based on "Programming Pearls" page 161The favorite data structure in the implementation of STL's sets and maps is a balanced search tree. These containers are based on these balanced trees to perform better in find and retrieval procedures; as a result, implementation of a dictionary requires the usage of such a mechanism that is not necessary optimized in "insertion" scenarios, as an alternative we can use a custom hash table + hash algorithm that performs much faster in inserting the words into a dictionary. Here is a basic comparison of these two methods STL's map container
#include #include #include #include #include #include using namespace std; struct node { char *word; int count; node* next; }; #define NHASH 22189 #define MULT 31 node* bin[NHASH]; unsigned int hash(const char *p) { unsigned int h = 0; for(; *p; p++) h = MULT * h + *p; return h % NHASH; } void incword(string word) { int hashCode = hash(word.data()); node* hashNode; for( hashNode = bin[hashCode]; hashNode != NULL; hashNode = hashNode->next) { if(strcmp(word.data(), hashNode->word) == 0) { hashNode->count++; return; } } hashNode = new node(); hashNode->count = 1; hashNode->word = new char[word.size()]; strcpy(hashNode->word, word.data()); hashNode->next = bin[hashCode]; bin[hashCode] = hashNode; } int main(int argc, char* argv[]) { const static char* InputFilePath = argv[1]; const static char* OutputFilePath = argv[2]; if(argc != 3) { cout << "The first argument is the input file path," " and the second one is the output file path" << counter =" 0;">> word) { incword(word); } cout << "Clock After Read Hash:" << counter =" 0;" hashnode =" bin[counter];" hashnode =" hashNode-">next) { fileOutputHash <<>word << "\t\t\t\t" <<>count <<> #include #include using namespace std; int find_substring(const char* mainString, const char* subString) { assert(mainString); assert(subString); int iFoundIndex = 0; const char* subPointer; bool bFound; for(; *mainString != 0; mainString++, iFoundIndex++) { for(bFound = true, subPointer = subString; *subPointer != 0; ++subPointer) { if(*(mainString + ((int)subPointer - (int)subString)) != *subPointer) { bFound = false; break; } } if(bFound) return iFoundIndex; } return -1; } #include #include #define LEARN_UNINITIZLIED_REAL_TYPES //main can return void or int for VC compiler //main has to return int for GCC compiler int main() { #ifdef LEARN_UNINITIALIZED_INT int iIsInitialized = 123; printf("iIsInitialized = %d\n", iIsInitialized); //Some random value auto int iautoUninitialized; //Warning C4700 from VC at compile time, exception //at run-time (run-time check failure) -858993460 //No warning from GCC, no exception at run-time: //the value is 1628438944 printf("iautoUninitialized = %d\n", iautoUninitialized); //Some random value int iUninitialized; //Warning C4700 from VC at compile time, exception //at run-time (run-time check failure) -858993460 //No warning from GCC, no exception at run-time: //the value is 0 (after we call the previous auto //value it becomes zero) printf("iUninitialized = %d\n", iUninitialized); #endif #ifdef LEARN_UNINITIZLIED_POINTERS //C4700 from VC compiler, First run-time check //failure that can be supassed but after that //we get access violation exception //that terminates the application //GCC doesn't complain and actually runs //it and shows some value auto int* myIninitializePointerToInt; printf("myIninitializePointerToInt = %d\n", *myIninitializePointerToInt); #endif #ifdef LEARN_UNINITIZLIED_REAL_TYPES //Unlike integer ojbects, real number objects //can contain values that correspond to //no genuine number like NAN //NAN (Not a number), math.h has especial //implementation defined values corresponding //to no actual real numbers. float fNAN = log((float)-2); //VCC: -1.#IND00 //GCC: -inf printf("fNAN = %f\n", fNAN); #endif return 0; } //For GCC compiler there must be a new line //at the end of file void ReverseString(char* string) { if(string == NULL) return; int iCharCounter = 0; for(iCharCounter = 0 ; *(string + iCharCounter) != 0 ; iCharCounter++); for(int iCharReverse = 0 ; iCharReverse < tempswap =" *(string"> void ToUpper(char* string) { if(!string) return; while(*string) { if( ('a' <= *string) && (*string <= 'z') ) { *string = *string + 'A' - 'a'; } string++; } return; } //atoi function: accepts an input string, //extracts all digits from the beginning of //the string and returns the final number int ascii_to_integer(char* string) { if(!string) throw std::invalid_argument( "Null string is not accepted"); int retVal = 0; if(('0' > *string) || (*string > '9')) throw std::invalid_argument( "There must be at least one digit at the beginning of the string"); while( ('0' <= *string) && (*string <= '9') && (*string != 0)) { retVal = (retVal * 10) + (*string - '0'); string++; } return retVal; } //Prints an integer using only putchar void print_integer(int value) { if((value / 10) == 0) { putchar('0' + value); } else { print_integer(value / 10); putchar('0' + (value % 10)); } } //Find n! using a recursive algorithm int FactorialRecursive(int n) { int retVal = 1; if( n < retval =" n" retval =" 1;" numcounter =" 1;"> //Fibonacci in recursive f(n) = f(n-1) + f(n-2) //Not a good solution, it doubles the stack size //each time is performs one operation int FibonacciRecursive(int n) { if(n < n ="="" n ="="" n ="="" n ="="" iminus2sum =" 1;" iminus1sum =" 1;" isum =" 0;" iiterator =" 1;" isum =" iMinus2Sum" iminus2sum =" iMinus1Sum;" iminus1sum =" iSum;"> double &rd1 = 0.0; double &rd2 = i; const double &rd1 = 0.0; const double &rd2 = i; vectors are dynamic arraysor
lists are linked liststhese are not precise definitions. Although in practical situations it is safe to think of vectors as dynamic arrays or lists as linked lists (especially with the level of abstraction that we employ while designing our code); there is a whole different idea behind it. Standard Template library's perception of vector is something that provides cheap and fast access to the items; similarly, list is a container that performs item insertion and removal at its minimum cost, definitely when the implementers of these classes are doing their job, their first choice for internal representation of these structures are arrays and linked lists, but it is an excellent practice to think of them as independent concepts. If you think of a list as a linked list and an iterator as a pointer then it is hard to accept one of the main ideas behind containers and iterators that saysthese are two standalone entities, because linked list and pointers are completely one body.
class MyBitmap { public: MyBitmap(int length, int height); ~MyBitmap(void); void set(int iHPos, int iVPos); void reset(int iHPos, int iVPos); void printBitmap(); private: int _length; int _height; char* _pBitHolder; void validateCoordinate(int iHPos, int iVPos); }; MyBitmap::MyBitmap(int length, int height) { if( ((length * height) % 8 ) != 0) throw std::invalid_argument( "Length by Height must be dividable by 8"); _length = length; _height = height; const int bitHolderSize = (length * height) / 8; _pBitHolder = new char[bitHolderSize]; for(int iInitializer = 0; iInitializer < itotalbitcount =" iVPos" ibytecounter =" iTotalBitCount" ibitcounter =" iTotalBitCount" itotalbitcount =" iVPos" ibytecounter =" iTotalBitCount" ibitcounter =" iTotalBitCount"> iHPos) throw std::out_of_range( "Invalid Argument for iHPos"); if(0 > iVPos) throw std::out_of_range( "Invalid Argument for iVPos"); if(iHPos >= _length) throw std::out_of_range( "Invalid Argument for iHPos"); if(iVPos >= _height) throw std::out_of_range( "Invalid Argument for iVPos"); } void MyBitmap::printBitmap() { int iTotalBitCount = 0; int iByteCounter = 0; int iBitCounter = 0; for(int iRowCounter = 0; iRowCounter < icolcounter =" 0;" itotalbitcount =" iRowCounter" ibytecounter =" iTotalBitCount" ibitcounter =" iTotalBitCount" cholderbyte =" _pBitHolder[iByteCounter];">return ((i & 1) == 0)To see if a number is a power of 2 (2^n)
return ((i & -i) == i); or return ((i & (i -1)) == 0); //By My Friend ZolioBitwise Tricks Bit Twiddling Hacks
#define ENOUGH_SIZE 10 char* itoa_plain(int value) { char* digits = new char[ENOUGH_SIZE]; char* temp = new char[ENOUGH_SIZE]; digits[0] = '\0'; do { int lastDigit = value % 10; value = value / 10; temp[0] = lastDigit + '0'; temp[1] = '\0'; strncat(temp, digits, strlen(digits)); strcpy(digits, temp); }while(value != 0); return digits; } char* itoa_standard(int value) { std::string digits; do { int lastDigit = value % 10; value = value / 10; digits.insert(digits.begin(), lastDigit + '0'); }while(value != 0); const unsigned long resultSize = digits.length(); char* result = new char[resultSize]; digits.copy(result, resultSize); result[resultSize] = 0; return result; } struct Node { Node(int value) { _value = value; _left = NULL; _right = NULL; } Node* _left; int _value; Node* _right; }; int MaxDepth(const Node* root) { if(root == NULL) return 0; int iLeftDepth = MaxDepth(root->_left); int iRightDepth = MaxDepth(root->_right); return (iLeftDepth > iRightDepth) ? (iLeftDepth + 1) : (iRightDepth + 1); } int findGreatestCommonValue(unsigned int m, unsigned int n) { if( (m == 0) || (n == 0) ) throw exception(); //Ensure that m is greater than n //otherwise swap them if(m < temp =" n;" n =" m;" m =" temp;" remainder =" m" m =" n;" n =" remainder;" remainder =" m"> try { System.Reflection.Assembly assembly = Assembly.LoadFile(/*Path*/); Console.WriteLine("Full Name:{0}\nName:{1}\nMajor Version:{2}\n Minor Version:{3}\nCodeBase:{4}" , assembly.FullName , assembly.GetName().Name , assembly.GetName().Version.Major , assembly.GetName().Version.Minor , assembly.CodeBase); Type[] allTypes = assembly.GetTypes(); foreach (Type type in allTypes) { FieldInfo[] fieldInfos = type.GetFields( BindingFlags.Static | BindingFlags.NonPublic); foreach (FieldInfo fieldInfo in fieldInfos) { Console.WriteLine("Field name:{0} , Declaring Type:{1} , Filed Type:{2} , Static:{3}" , fieldInfo.Name , fieldInfo.DeclaringType.ToString() , fieldInfo.FieldType , fieldInfo.IsStatic); if (fieldInfo.IsStatic) { Console.WriteLine("Static = {0}" , fieldInfo.GetValue(null)); fieldInfo.SetValue(null , 200); Console.WriteLine("Static = {0}" , fieldInfo.GetValue(null)); } } } Console.WriteLine("Done Loading Assembly"); } catch (Exception exception) { Console.WriteLine(exception.Message); }This pattern is not necessary related to a class. for example in COM there are situations where we need to have one instance of a COM component, this component can be a collection of classes, still this is called SingletonDepending on the language there are different ways to implement this pattern. The only common point is that it is implemented by the class itself, and it is the class itself that manipulates its instantiation process. All the client requests for instantiation will go through one particular channel and will end-up in retrieving one similar instance. The first request for instance retrieval will cause instantiation, the subsequent requests will retrieve the already created instance. C++
/////////Header File class ASingleInstanceClass { private://To seal the class ASingleInstanceClass() { } public: static ASingleInstanceClass* GetInstance(); private: static ASingleInstanceClass* m_instance; }; ////////////CPP File #include "ASingleInstanceClass.h" ASingleInstanceClass* ASingleInstanceClass::m_instance = NULL; ASingleInstanceClass* ASingleInstanceClass::GetInstance() { if(m_instance == NULL) { m_instance = new ASingleInstanceClass; } return m_instance; } C# We can employ the same approach in C# to create a singleton class; however C# has this new capability called static constructors that can be used insteadpublic sealed class ASingleInstanceClass { static readonly ASingleInstanceClass instance = new ASingleInstanceClass(); static ASingleInstanceClass() { } ASingleInstanceClass() { } public static ASingleInstanceClass Instance { get { return instance; } } }
//See: http://www.cppreference.com/cppio/index.html //The library allows programmers to do file //input and output with the ifstream and ofstream classes #include #include #include #include using namespace std; int main(int argc, char* argv[]) { const static char* InputFilePath = argv[1]; const static char* OutputFilePath = argv[2]; //At least two arguments must be provided if(argc != 3) { cout << "The first argument is the input file path," " and the second one is the output file path" <<> setFileData; //Read Data ifstream fileInput(InputFilePath); copy( istream_iterator (fileInput) , istream_iterator () , inserter(setFileData, setFileData.begin()) ); //Write Sorted Data ofstream fileOutput(OutputFilePath); copy( setFileData.begin() , setFileData.end() , ostream_iterator(fileOutput, "\n")); return 1; } // Sequential search = O(N) int find1(int n, char array[MAX_STR][MAX_LEN],char key[MAX_LEN]) { int i; for(i=0;i<> //O(log2 N) int find2(int n, char array[MAX_STR][MAX_LEN],char key[MAX_LEN]) { int low = 0; int high = n-1; int mid; int outcome; while( low <= high ) { mid = (low+high) / 2; outcome = strcmp(array[mid],key); if( outcome==0 ) return(mid); else if( outcome < low =" mid+1;"> 0 ) high = mid-1; } return(-1); }Function templates are functions that are parameterized so that they represent a family of functions; it means that we can have the same functional behavior for different data types.
They start with the keyword "template" template template inline T const& max(T const& a, T const& b) { return a <> inline int const& max (int const& a, int const& b) { return a <> inline T const& max(T const& a, T const& b) { return a <> inline T const& max(T const& a, T const& b, T const& c) { return ::max (::max(a, b), c); } //Static allocation, compiler allocation, stack int * p; //Dynamic allocation, runtime allocation, heap int* p = new int; int* myArray = new int[50]; //myArray[0] *myArray; //myArray[1] *(myArray + 1); //Deleting delete [] myArray;