Nadeem Afana's blog

How MIT Keytab Files Store Passwords

Nadeem — Thu, 29 Dec 2016 14:29:00 -1100

How Kerberos Keys Are Generated

A Keytab file is a way to store your passwords so that you can authenticate to Kerberos services without typing your password again. It is similar to logon tokens in a way. I initially thought storing passwords in a keytab file was straightforward, but once I started digging into the internals, I realized I was wrong, well, half wrong because in the case of RC4-HMAC, it is so simple.

In general, the password is not stored in raw format. A derived key is generated based on the password, and the key is stored instead.

There are multiple encryption types that Keytabs support, however, I will discuss only the following formats, which are the most common anyways:

RC4-HMAC
AES-128-CTS-HMAC-SHA1-96
AES-256-CTS-HMAC-SHA1-96

RC4-HMAC

This is the simplest case:

Key = Md4 (Unicode(password))

The key is simply the MD4 hash of the password.

The following C# code will compute the key given a password.

// Packages required
// Install-Package ExtensionMethods
// Install-Package Afana.Cryptography
void Main()
{
	
	byte[] key = GetRc4HmacKey("password");
	Console.WriteLine(key.ToHexString());
	// outputs 8846f7eaee8fb117ad06bdd830b7586c
	
	// Note: For .ToHexString() and other extension methods, Install-Package ExtensionMethods.
	
}
byte[] GetRc4HmacKey(string password)
{
	using (HashAlgorithm hash = new Md4()) {
		return hash.ComputeHash(password.ToBytes(Encoding.Unicode));
	}
}

AES

When it comes to AES, things are more complicated than a simple hash. Although key generation is documented in RFC3962, the process is hard to follow through and is rather complicated.

AES-128-CTS-HMAC-SHA1-96

The encryption algorithm used by AES-128-CTS-HMAC-SHA1-96 is AES CBC CTS with 128-bits key size. CTS, Cipher Text Stealing, generates a cipher text which has exactly the same size as the input plain text. CTS won't matter in our case since the input data size is exactly 16 octets, one block, so we could simply use AES CBC instead.

The slightly simplified formula for generating the AES 128-bit key is:

        tkey = random2key(PBKDF2(passphrase, salt, iter_count, keylength))
        key = E(tkey, NFold("kerberos"), initial-cipher-state))
        E = Encrypt using AES-128-CBC-CTS

random2key is an identity function, which means it returns the input as is, so this function can be safely ignored.

PBKDF2 is a standard function (RFC2898) that produces a derived key given a password. Its purpose is to make password cracking much more difficult.

passphrase is the password itself. salt is the realm + user name. iter_count is 4,096. keylength is 16 bytes (128 bits).

AES CBC works in terms of blocks, which means if the data to be encrypted is less than one block in size, it must be padded. Because the string "kerberos" is less than one block (16 bytes), it must be expanded and NFold is what expands it to 16 bytes. NFold is a function that takes in a variable-length input and returns a fixed-length output. The .NET Framework does not provide an implementation of n-folding, so I had to write my own.

Here is a fully working C# example that computes the key:

// Packages required
// Install-Package ExtensionMethods
// Install-Package Afana.Cryptography

void Main()
{
	
	byte[] key = GetAes128Sha1Key("password", "nadeem", "MY.REALM.COM");
	Console.WriteLine(key.ToHexString());
	// outputs 907e1f9fe6fa7359543f296d6552444c
	
	// Note: For .ToHexString(), Install-Package ExtensionMethods.
	
}

byte[] GetAes128Sha1Key(string password, string userName, string realm)
{
	// AES-128-CTS-HMAC-SHA1-96
	const int keySize = 16;
	byte[] pbkdf2 = ComputePbkdf2(password.ToBytes(), (realm+userName).ToBytes(), keySize);	
	byte[] nfolded = NFold.Compute("kerberos".ToBytes(), keySize);
	return AesCts.Encrypt(nfolded, pbkdf2, new byte[keySize]);
}

// Pbdkf2 based on HMACSHA1
public static byte[] ComputePbkdf2(byte[] password, byte[] salt, int size)
{
	using (Rfc2898DeriveBytes pbkdf2 = new Rfc2898DeriveBytes(password, salt, 4096)) {
		// Truncate hash to "size" bytes.
		return pbkdf2.GetBytes(size);
	}
}

AES-256-CTS-HMAC-SHA1-96

The encryption algorithm used by AES-256-CTS-HMAC-SHA1-96 is AES CBC CTS with 256-bits key size.

Unlike AES 128, there a few extra steps for key generation:

tkey = random2key(PBKDF2(passphrase, salt, iter_count, keylength))
k1 = E(tkey, NFold("kerberos"), initial-cipher-state))
k2 = E(tKey, k1, initial-cipher-state)
Key = k1 || k2
E = Encrypt using AES-256-CBC-CTS

// Packages required
// Install-Package ExtensionMethods
// Install-Package Afana.Cryptography

void Main()
{
	byte[] key = GetAes256Sha1Key("password", "nadeem", "MY.REALM.COM");
	Console.WriteLine(key.ToHexString());
	// outputs 08a29fccbc66d60f95ec6122545844adacff001393d79640d3ba3da17562ebe6
	// Note: For .ToHexString(), Install-Package ExtensionMethods.
}

byte[] GetAes256Sha1Key(string password, string userName, string realm)
{
	// AES-256-CTS-HMAC-SHA1-96
	byte[] pbkdf2 = ComputePbkdf2(password.ToBytes(), (realm + userName).ToBytes(), 32);	
	byte[] nfolded = NFold.Compute("kerberos".ToBytes(), 16);
	byte[] iv = new byte[16];
	byte[] k1 = AesCts.Encrypt(nfolded, pbkdf2, iv);
	byte[] k2 = AesCts.Encrypt(k1, pbkdf2, iv);
	// k1 || k2	
	return k1.Concat(k2).ToArray();
}

// Pbdkf2 based on HMACSHA1
public static byte[] ComputePbkdf2(byte[] password, byte[] salt, int outputSize)
{
	using (Rfc2898DeriveBytes pbkdf2 = new Rfc2898DeriveBytes(password, salt, 4096)) {
		// Truncate hash to "outputSize" bytes.
		return pbkdf2.GetBytes(outputSize);
	}
}

.NET Cryptographic Functions

Nadeem — Tue, 27 Dec 2016 10:44:00 -1100

Cryptographic functions

Afana.Cryptography Nuget package is meant to be a complementary set to the .NET Framework. It is not a replacement. It is still work in progress, and I will add more functions if I receive enough requests from people. For example, the .NET Framework has no implementation of AES CTS or N-Fold.

To add the library to your project, open Package Manager Console, select your project and type

Install-Package Afana.Cryptography

The following functions are available so far

AES CBC CTS

// using Afana.Cryptography.Aes
void Main()
{
	byte[] plainText = { 0x0c, 0x00, 0x04, 0x00, 0x0c, 0x00, 0x18, 
                         0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x00, 
                         0x04, 0xa
                       };
	byte[] iv = { 0x4a, 0xcd, 0xca, 0x4f, 0xa8, 0xb3, 0x51, 0x8b, 
                  0x8b, 0xd0, 0x39, 0xc3, 0x0c, 0x61, 0xad, 0xbf 
                };
	byte[] key = { 0xed, 0xb0, 0xb0, 0x3b, 0x59, 0xf2, 0xf5, 0xe7, 
                   0x4c, 0x04, 0xe5, 0xb8, 0xcd, 0x56, 0x40, 0x5c, 
                   0xed, 0xb0, 0xb0, 0x3b, 0x59, 0xf2, 0xf5, 0xe7, 
                   0x4c, 0x04, 0xe5, 0xb8, 0xcd, 0x56, 0x40, 0x5c 
                 };
 	
	byte[] cipherText =  AesCts.Encrypt(plainText, key, iv);
	
    Console.WriteLine(cipherText.ToHexString()); 
    // For .ToHexString(), Install-Package ExtensionMethods
	
	// Outputs fc9112f1edc30d68544b2951612e66c3
}

Rotate Left

You can rotate left an array of bytes, not only integers.

// using Afana.Cryptography
void Main() 
{
	byte[] value = new byte[] { 0xa, 0xb, 0xc, 0xd };
	byte[] result = CryptoHelper.RoL(value, 5);
	
	Console.WriteLine(result.ToHexString()); 
	// Outputs 416181a1	
	
	// Note: For .ToHexString(), Install-Package ExtensionMethods
}

Rotate Right

Rotates right an array of bytes, not only integers.

// using Afana.Cryptography
void Main() 
{
	byte[] value = new byte[] { 0xa, 0xb, 0xc, 0xd };
	byte[] result = CryptoHelper.RoR(value, 5);
	
	Console.WriteLine(result.ToHexString()); 
	// Outputs 68505860	
	
	// Note: For .ToHexString(), Install-Package ExtensionMethods
}

Greatest Common Divisor

Calculates the Greatest Common Divisor for two integers.

// using Afana.Cryptography
void Main() 
{
	 
	int result = CryptoHelper.Gcd(-15, 21);	
	Console.WriteLine(result);
	// Outputs 3

	result = CryptoHelper.Gcd(2, 4);
	Console.WriteLine(result);
	// Outputs 2		
}

Least Common Multiple

Calculates the Least Common Multiple for two integers.

// using Afana.Cryptography
void Main() 
{
	 
	int result = CryptoHelper.Lcm(-15, 21);	
	Console.WriteLine(result);
	// Outputs 105	

}

N-Folding

N-Folds an array of bytes. See RFC3961 for more information.

// using Afana.Cryptography
void Main() 
{
	byte[] plainText = "kerberos".ToBytes();	
	byte[] nfolded = NFold.Compute(plainText, 32);

	Console.WriteLine(nfolded.ToHexString());
	// Outputs 6b65726265726f737b9b5b2b93132b935c9bdcdad95c9899c4cae4dee6d6cae4	

	// Note: For .ToHexString(), Install-Package ExtensionMethods
}

.NET AES CTS Implementation

Nadeem — Tue, 15 Nov 2016 11:04:00 -1100

I was looking for an AES CTS .NET implementation but could not find any. The .NET Framework has an enumeration value for CTS; however, the framework throws an exception if you try to use it as it is not actually implemented. I then decided to write one and share it:

Install using NuGet

Install-Package AesCts

// using Afana.Cryptography.Aes
void Main()
{
	byte[] plainText = { 0x0c, 0x00, 0x04, 0x00, 0x0c, 0x00, 0x18, 
                             0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x00, 
                             0x04, 0xa};
	byte[] iv = { 0x4a, 0xcd, 0xca, 0x4f, 0xa8, 0xb3, 0x51, 0x8b, 
                      0x8b, 0xd0, 0x39, 0xc3, 0x0c, 0x61, 0xad, 0xbf };

	byte[] key = { 0xed, 0xb0, 0xb0, 0x3b, 0x59, 0xf2, 0xf5, 0xe7, 
                       0x4c, 0x04, 0xe5, 0xb8, 0xcd, 0x56, 0x40, 0x5c, 
                       0xed, 0xb0, 0xb0, 0x3b, 0x59, 0xf2, 0xf5, 0xe7, 
                       0x4c, 0x04, 0xe5, 0xb8, 0xcd, 0x56, 0x40, 0x5c };
 	
	byte[] cipherText =  AesCts.Encrypt(plainText, key, iv);
	Console.WriteLine(cipherText.ToHexString()); 
        // For .ToHexString(), Install-Package ExtensionMethods
	
	// Outputs fc9112f1edc30d68544b2951612e66c3
}

Restoring Classic Calculator in Windows 10

Nadeem — Mon, 27 Jun 2016 11:13:00 -1100

I recently installed a new version of Windows 10 and noticed that Windows Calculator interface has changed dramatically.

I personally didn't like. It took me a while to figure out how to perform inverse trignometric functions. Finally, I realized their buttons only show up when the window size is wide enough!

So I decided to restore the classic Calcualtor app. If would like the classic Calculator interface back, you will need copy the classic Windows Calculator files from an earlier version of Windows 10, or from Windows 8 or 7 (this works too). I attached the needed files to this post. If you don't trust these, you have no choice but to get them manually.

Two files are needed from an earlier version of Windows: %SystemRoot%\system32\calc.exe and %SystemRoot%\system32\en-US\calc.exe.mui.
Note that the path might be slightly different in your case.
Download calc.zip and extract the files to a folder such as C:\calc\.
If you copied the two mentioned files manually, then place them in the same folder. Make sure you name the files calc.exe and calc.exe.mui.
Run command prompt as Administrator by right clicking on Command prompt and then choosing 'Run as administrator'.
Run the file install.bat and press y when prompted.
You might need to tweak the paths in install.bat if your Windows version is not en-US.

You should see the following output if every thing went well.

C:\Windows\system32>C:\calc\install.bat
Taking ownership of calc.exe...
SUCCESS: The file (or folder): "C:\Windows\system32\calc.exe" now owned by the administrators group.
Are you sure (Y/N)?y
processed file: C:\Windows\system32\calc.exe
Taking ownership of calc.exe.mui...
SUCCESS: The file (or folder): "C:\Windows\system32\en-US\calc.exe.mui" now owned by the administrators group.
Are you sure (Y/N)?y
Copying calc.exe...
        1 file(s) copied.
Copying calc.exe.mui...
        1 file(s) copied.

Enjoy!

Memory Barriers in .NET

Nadeem — Fri, 10 Jul 2015 08:49:00 -1100

Nonblocking programming can provide performance benefits over locking, but getting it done right is significantly harder and requires careful testing.

When it comes to memory barriers, there is all sorts of confusion and misleading information. Because memory barrier can be counterintuitive, using them wrongly is easy, and applying them correctly requires a lot of effort and headache. The benefits memory barriers provide may not be worth it in most high-level applications. However, memory barriers are handy in performance critical software.

In the past, a system with a single processor executed concurrent threads using a trick called "timeslicing", where one thread is running and the others are sleeping. This means that all memory accesses done by one thread appeared in an exact order to all the other running threads. This is called a sequential consistency model. Nowadays, multiprocessor systems are very common and concurrent threads are truly running at the same time, so sequential consistency is not guaranteed because

The compiler or JIT might re-order the memory instructions for optimization.
The processor can also re-order memory instructions for performance through different mechanisms including caching, load speculation, and delaying store operations.

Consider the following program.

Example 1

int x = 0, y = 0, r1 = 0, r2 = 0;
public void Thread1()
{	 
	y = 1;  // Store y
	r1 = x; // Load x	 		 
	  
}
	
public void Thread2()
{
	x = 1;  // Store x
	r2 = y; // Load y	  
}

If the methods run on different threads, there are a few possibilities for the values of r1 and r2:

Thread1 finishes before Thread 2 starts, so that r1 = 0 and r2 = 1.
Thread 2 finishes before Thread 1 starts, so that r2 = 0 and r1 = 1.
Both Thread1 and Thread2 interleave, so that either one of the following will happen:
1. r1 = 1 and r2 = 1 or
2. r1 = 0 and r2 = 1 or
3. r1 = 1 and r2 = 0

In all of the cases above, either r1 = 0 or r2 = 0 but never both r1 and r2 are 0. Is it possible that both r1 = 0 and r2 = 0?

The answer is "yes" though it is counterintuitive, but how ?

A processor can defer its store operations in a buffer, and this causes operations to be out of order. If both stores to x and y are delayed, then the load from x in Thread 1 will read 0, and the load from y in Thread2 will read 0 too!

The real execution order might look like this:

public void Thread1()
{	 
    r1 = x;  // Load x
    y  = 1;  // Store y	   		 
	  
}
	
public void Thread2()
{	  
    r2 = y;  // Load y	  
    x  = 1;  // Store x
}

If you want to try it yourself, compile and run the following program. I ran the following program on my Intel64 machine.

NOTE: You must compile in release mode.

using System;
using System.Threading.Tasks;
namespace ConsoleApplication
{
    class Program
    {
        static int x = 0;
        static int y = 0;
        static int r1 = 0;
        static int r2 = 0;
        static void Main(string[] args)
        {
            do {
                x = y = r1 = r2 = 0;
                var t1 = new Task(() => { Thread1(); });
                var t2 = new Task(() => { Thread2(); });
                t1.Start();
                t2.Start();
                Task.WaitAll(t1, t2);
            } while (!(r1 == 0 && r2 == 0));
            Console.WriteLine("r1={0}, r2={1}", r1, r2);
        }
        static public void Thread1()
        {
            y = 1;  // Store y
            r1 = x; // Load x	 		 
        }
        static public void Thread2()
        {
            x = 1;  // Store x
            r2 = y; // Load y	  
        }
    }
}

Even if you declare the variables as volatile, it won't help! I'll discuss volatile shortly. Anyways, to fix the problem, add a memory barrier Thread.MemoryBarrier() between the store and load operations in each thread. We'll come back to this example later after discussing memory barriers.

The previous example was a hardware optimization. Let's see another example where software manifests its optimization.

Example 2 The following loop will run forever. Why ?

bool terminate = false;
	
var t = new Thread(() => { 		
	int x = 0; 
	while(!terminate){x = x * 1;}
});
	
t.Start();
Thread.Sleep(2000);
terminate = true;
t.Join();
Console.WriteLine("Done.");

Looking at the disassembly code, I see the following for the thread t body:

00B400E1      mov         ebp,esp      
00B400E3      movzx       eax,byte ptr [ecx+4] ; Load terminate into EAX
00B400E7      test        eax,eax  
00B400E9      jne         00B400EF  
00B400EB      test        eax,eax  
00B400ED      je          00B400EB  
00B400EF      pop         ebp  
00B400F0      ret

This time it is JIT, not the hardware. It's clear that JIT has cached the value of the variable terminate in the EAX register. The program is now stuck in the loop highlighted above. If you don't know assembly well, the highlighted section above is equivalent to the following C# code.

while(true){}

Either using a lock or adding a Thread.MemoryBarrier inside the while loop will fix the problem. Or you can even use Volatile.Read.

The purpose of the memory barrier here is only to suppress JIT optimizations.

Now that we have seen how software and hardware can reorder memory operations, it's time to discuss memory barriers.

Memory Barriers

We saw how the hardware and JIT could reorder memory instructions. This can be a problem for communication between different processors as we saw in the examples above. Memory barriers (aka memory fences) are a way to tell the compiler, JIT and the processor to restrict the ordering of memory instructions.

It's important to note, in general, memory barriers are needed for communication between different processors (There are exceptions of course, such as using a memory barrier to suppress the compiler or JIT optimizations). If the system has only one single processor, then there may not be a need for memory barriers.

There are different kinds of memory barriers:

Store memory barrier (or write memory barrier)
A store memory barrier ensures that no STORE operation can move across the barrier.

All the STORE operations that appear before the memory barrier will appear to happen before all the STORE operations that appear after the memory barrier. The equivalent CPU instruction is SFENCE.

This has no effect whatsoever on LOAD operations
Load memory barrier (or read memory barrier)
A load memory barrier ensures that no LOAD operation can move across the barrier.

All the LOAD operations that appear before the barrier will appear to happen before all the LOAD operations that appear after the memory barrier. The equivalent CPU instruction is LFENCE.

This has no effect whatsoever on STORE operations.
Full memory barrier
A full memory barrier ensures that no STORE or LOAD operation can move across the barrier.

All the STORE and LOAD operations that appear before the barrier will appear to happen before all the STORE and LOAD operations that appear after the barrier. The equivalent CPU instruction is MFENCE.

A full memory barrier is the strongest and interesting one. At least all of the following generate a full memory barrier implicitly:
- Thread.MemoryBarrier
- C# Lock statement
- Monitor.Enter and Monitor.Exit
- Task.Start
- Task.Wait
- Task continuations
- Interlocked class mehods
- Any signaling operation such as ManualResetEvent and AutoResetEvent
- Thread.Sleep
- Thread.Join
- Thread.SpinWait
- Thread.VolatileWrite
- Thread.VolatileRead
Implicit Barriers

The following are one-way fences based on the direction of movement.
Acquire
Ensures that no STORE or LOAD operation that appears after the barrier will move before the barrier. Operations that appear before the barrier can move after the barrier.

Reading a volatile variable or calling Volatile.Read is an acquire fence.
Release
Ensures that no STORE or LOAD operation that appears before the barrier will move after the barrier. Operations that appear after the barrier can move before the barrier.

Writing to a volatile variable or calling Volatile.Write is a release fence.

Memory Ordering

Now after introducing memory barriers, let's take a look at the memory models for certain hardware and CLR. The following table describes whether reordering is allowed for certain memory operations. A comma is used to indicate two consecutive operations. For example, Load, Load indicates a load operation followed by another load operation.

	Hardware			CLR 2.0+
Operation	Intel x86 & Intel64	IA 64	AMD64	Without Volatile	With Volatile
LOAD, LOAD	No	Yes	No	Yes	No
LOAD, STORE	No	Yes	No	Yes	No
STORE, STORE	No	Yes	No	No	No
STORE, LOAD	Yes, only if load and store are to different locations.	Yes	Yes, only if load and store are to different locations.	Yes	Yes

A few comments based on the table above and after examining detailed documentation:

.NET Framework 4.5 does not support Itanium processors. However, I added it in the table for legacy purpose only.
Intel x86, Intel64 and AMD 64 are the strongest hardware memory models and IA64 is the weakest.
CLR 2.0+ prevents reordering two store operations, even without using volatile.
For x86, Intel64 and AMD 64, a LOAD,LOAD operation usually is not reordered; however, Intel mentions that a processor can reorder a LOAD,LOAD operation, but this reordering should not be visible to software. See Section 8.2.3 in Intel® 64 and IA-32 Architectures Software Developer's Manual: Volume 3A
AMD64 documentation mentions that a LOAD,LOAD operation can be reordered only if the memory type is different for each LOAD (eg LOAD (WB), LOAD (WC+) . See table 7-3 in AMD64 Architecture Programmer's Manual Volume 2: System Programming
If you have Intel x86, Intel64 or AMD64, then volatile does not provide any extra hardware ordering restrictions. This means stores by default are release fences and reads are acquire fences.

So why use volatile?

Although using volatile is not recommended because of its subtleties, it can be used to suppress JIT compiler optimizations. Additionally, some older programs still run on IA64.

Atomic Operations

Although a C# lock eliminates the need for a memory barrier. A C# lock is sometimes considered an expensive operation because it can lead to contention and thread descheduling. Smart programmers avoid locking if possible. Fortunately, processors provide atomic instructions such as xchg. Also, a simple write or read is considered an atomic operation on modern processors. Atomic instructions happen instantaneously and are much more efficient than locking. For example, the Interlocked class exposes methods that provide atomic behavior that take advantage of the processor atomic instructions directly.

Why do we need atomic instructions in high-level programs?

In the following example, if you run the two methods concurrently on two different threads, you expect result to be 200,000.

public int  result;
      
public void ThreadA()
{
    for (int i = 1; i <= 100000; i++) {
        result++;
    }
}
public void ThreadB()
{
    for (int i = 1; i <= 100000; i++) {
        result++; 
    }
}

But after running the example on my machine, I see the following:

In fact, every time I run it, I get different a result!

Note that even when declaring result as volatile, I always a corrupt value.

Looking at the disassembly code, I see that JIT translates it into:

000007FE6F1501B5 mov         eax,dword ptr [rcx+8]  ; Load result into EAX
000007FE6F1501B8 inc         eax  			        ; increment EAX 
000007FE6F1501BA mov         dword ptr [rcx+8],eax  ; Load EAX into result

Obviously, the above instructions are not atomic. Imagine that both threads execute at the same time, and the 2nd thread reads the same value for result as the first thread, then both will set result to the same value. This happens because result was out of date. That is also why result is always less than or equal to 200,000.

Although locking around the increment would solve the problem, there is a more efficient way to fix the problem. Interlocked comes to rescue:

public void ThreadA()
{
    for (int i = 1; i <= 100000; i++) {
        Interlocked.Increment(ref result);
    }
}
public void ThreadB()
{
    for (int i = 1; i <= 100000; i++) {
        Interlocked.Increment(ref result);
    }
}

Now the result is always guaranteed to be 200,000.

Looking at the disassembly after we introduced the Interlocked class

000007FE6F1601F0        mov         eax,1  
000007FE6F1601F5        lock xadd   dword ptr [rcx+8],eax   ; add 1 to result
000007FE6F1601FA        cmp         byte ptr [rcx],0      
000007FE6F1601FD 	    mov         eax,1  
000007FE6F160202        lock xadd   dword ptr [rcx+8],eax   ; add 1 to result
000007FE6F160207        add         edx,2  		 	        ; i = i + 2
000007FE6F16020A 	    cmp         edx,186A0h   		    ; if i <= 10,000 
000007FE6F160210        jle         000007FE6F1601F0 	    ; loop again

JIT used a locked instruction on my Intel64 machine. A locked instruction is guaranteed to be atomic according to Intel documentation. XADD is an exchange-and-add instruction, which in this case exchanges EAX with result and stores the sum of both in result.

Why did JIT not use lock add instead of lock xadd?

It's because the implementation of Interlocked.Increment in the .NET Framework looks like this

ExchangeAdd(ref location1, value);

Interlocked has other useful methods such as Decrement, Add, and CompareExchange.

Let's revisit the Example 1 to see how JIT translates a memory barrier:

public void Thread1()
{	 
    y  = 1;  // Store y 
    Thread.MemoryBarrier();      	   		 
    r1 = x; // Load x
}
	
public void Thread2()
{	  
    x  = 1;  // Store x 
    Thread.MemoryBarrier();
    r2 = y; // Load y	  
}

Looking at the disassembly of Thread1 method after introducing the memory barriers, we see:

01270270       mov         dword ptr ds:[11C32A0h],1    ; Store 1 in y
0127027A       lock or     dword ptr [esp],0            ; Thread.MemoryBarrier()    
0127027F       mov         eax,dword ptr ds:[011C329Ch] ; Load x into EAX

On my Intel64 machine, JIT replaced the memory barrier with a dummy instruction (ie lock or). In this instance, this instruction does change the value of anything (since any value bitwise OR 0 yields the same value). However, locked instructions have the same effect as a memory barrier in my case, which means they also flush the store buffer.

Facts about memory barriers

Although the effects of memory barriers depend on the hardware, software must be designed in a way to allow for the common denominator. Additionally, there are common facts about memory barriers:

Each processor sees its own access orders without needing a memory barrier.
Inserting a memory barrier in one processor does not have a direct effect on another processor unless they both have matching memory barriers.
If a variable is being updated by many processors, then the sequence of values observed by one processor will be the same sequence of the other processors.

Inserting a memory barrier does not guarantee the order of operations before the memory barrier. A barrier can be thought of as a line of separation. For example

Processor 1
X = 1
B = 1
Y = 1
memory barrier
Z = 2

The stores from processor 1 will be committed in 1 of 6 different ways:

{X = 1, B = 1, Y = 1, Z = 2}
{X = 1, Y = 1, B = 1, Z = 2}
{B = 1, X = 1, Y = 1, Z = 2}
{B = 1, Y = 1, X = 1, Z = 2}
{Y = 1, X = 1, B = 1, Z = 2}
{Y = 1, B = 1, X = 1, Z = 2}

In the example below, assuming X = Y = 0, if LOAD Y comes up with 1, then LOAD X must come up with 1.

Processor 1	Processor 2
X = 1	LOAD Y
memory barrier	memory barrier
Y = 1	LOAD X

In the example below , assuming X = Y = 0, if LOAD Y comes up with 1, then LOAD X cannot come up with 1.

Processor 1	Processor 2
Y = 1	X = 1
memory barrier	memory barrier
LOAD X	LOAD Y

In the example below, assuming X = Y = 0, if LOAD X comes up with 1, then processor 1 store to Y must happen after processor 2 store to Y. Therefore, Y must be 2.

Processor 1	Processor 2
Y = 2	Y = 1
memory barrier	memory barrier
LOAD X	X = 1

Load Speculation

Modern processors prefetch data from main memory before the program needs it. The goal is to predict which data the program needs to consume. This makes the data immediately available when the program execution instruction gets to the point of the LOAD.

It is possible that the processor did not need the value it had prefecthed. This is probably because a branch has circumvented the execution flow. In this case, the prefecthed value can be discarded or cached for later use.

Although load speculation makes a program run faster, it can make the program see stale values.

For example, initially assume X = Y = 0.

Example 3

Processor 1	Processor 2
	LOAD X
Y = 2	Long latency instructions such as division and square-root
	LOAD Y

Figure 7: Load Speculation. The green color indicates a current value, whereas the red color indicates a stale value. The dashed line indicates the processor is busy.

The order of memory operations as in the above figure:

Initially, processor 2 loads X where its value is 0.
Processor 2 starts executing long latency instructions. The processor realizes that there is an upcoming load of Y, so it speculates so it pretches Y before even the program got to the point where Y is needed.
In the meantime, processor 1 updates the value of Y to 2. However, this new value is not visible to processor 2 yet.
When processor 2 has finished the long latency instructions, the old value of Y is immediately served.
The value "0" of Y that processor 2 has prefetched is now out of date!

A memory barrier in this case would fix the issue:

Processor 1	Processor 2
	LOAD X
Y = 2 memory barrier	Long latency instructions such as division and square-root
	memory barrier LOAD Y

The memory barrier above LOAD Y tells processor 2 to check the value of Y since it could have changed. If Y has changed, then it will be reloaded from memory.

Memory Barrier Pairing

If the purpose of a memory barrier is only multiprocessor synchronization, and by that, I mean hardware synchronization and not suppress JIT or compiler optimizations, then memory barriers should be paired.

Looking again at solved Example 1

Note that the store to y before the barrier in Thread1 matches the load of y after the barrier in Thread2, and so is the same for x.

A single barrier alone will not solve the problem that we discussed earlier. You can try that yourself by removing one of the barriers and running the program again!

A lack pf pairing can cause problems, for example, consider X = Y = 0 initially.

Example 4

Processor 1	Processor 2
X = 1
memory barrier
Y = 1
	LOAD Y
	LOAD X

Processor 2 might see the order of memory operations as follows

Figure 10: Barrier Missing. The green color indicates a current value, whereas the red color indicates a stale value.

Despite the barrier in processor 1, processor 2 might perceive the wrong value of X. To solve the problem, a memory barrier is needed above the LOAD of X in processor 2.

Processor 1	Processor 2
X = 1
memory barrier
Y = 1
	LOAD Y
	memory barrier
	LOAD X

Figure 11: Added missing barrier. The green color indicates a current value, whereas the red color indicates a stale value.

Now, the effects before the memory barrier in processor 1 (STORE X = 1) are available after the barrier in processor 2 (LOAD X).

Cache Coherence

Processors rely heavily on caches. It is in fact common for each core to have its own cache, and it is possible for some cores to share the same cache. Modern Intel processors support a mechanism called "Cache locking" where the processor instead of locking on the system bus, it updates the value internally in its cache and relies on cache coherency.

Maintaining the coherence of all the caches is not the programmer's job. However, the programmer should be aware of the consequences of cache coherence. Although all caches should be coherent, the order in which the memory operations happen is not guaranteed. Think of cache coherence as a notification system, if a processor makes changes, all the other processors will be notified immediately of the changes, but the actual changes may not be applied immediately because a cache has a queue of all the memory operations that need to be applied to it. Memory barriers have effects on this cache and therefore can restrict ordering.

A cache line is a fixed-length block of data. Data flows among processors' caches and main memory in terms of cache lines, not individual bytes.

Looking at example 4 again,

Processor 1	Processor 2
X = 1
memory barrier
Y = 1
	LOAD Y
	memory barrier
	LOAD X

Is it possible that LOAD Y comes up with 0 even though it ran after processor 1 STORE Y = 1?

The answer is "yes".

The barrier between the loads in processor 2 does not guarantee that Y will come up with 1, but it does guarantee that X will always be 1 provided that it ran after processor 1's memory barrier. See Facts about memory barriers.

Here is how Y might come up with 0 instead of 1 even though it ran after the store Y = 1:

Assuming X = Y = 0 initially and both X and Y are in 1 and 2 caches.

Processor 1 executes X = 1. It sends an "invalidate" message to processor 2 in order to evict the matching cache line.
Processor 2 receives the "invalidate" message from processor 1, queues the message and acknowledges it by responding to it immediately.
Processor 1 receives processor 2 response and continues by flushing its store buffer due to the memory barrier.
Processor 1 executes Y = 1. It sends an "invalidate" message in order to evict the matching cache line in processor 2.
Processor 2 receives the "invalidate" message from processor 1, queues the message, acknowledges it, and immediately responds to it.
Processor 2 executes LOAD Y. Since Y is already in its cache, the value 0 is used.
Processor 2 now sees the memory barrier and must wait until all the queued "invalidate" messages are processed, and therefore it invalidates the cache lines containing X and Y.
Processor 2 executes LOAD X. Since the cache line of X is no longer in processor 2 cache, it sends a "read" message.
Processor 1 receives the "read" message of processor 2 and transmits the cache line containing the new value of X.
Processor 2 receives the cache line with the new value "1" of X.

To fix this issue, a new pair of memory barriers is needed:

Processor 1	Processor 2
X = 1
memory barrier
Y = 1
memory barrier
	memory barrier
	LOAD Y
	memory barrier
	LOAD X

Note that one barrier alone is not enough.

The new barrier in processor 1 is needed to flush the store buffer, and the new barrier in processor 2 is needed to make sure Y is up to date by flushing the invalidate queues.

Notice how all the barriers are paired.

ASP.NET MVC 5 Internationalization · Strings Localization on the client-side

Nadeem — Sat, 31 May 2014 18:26:00 -1100

Download code

In this post, I will show a technique on how to localize and use strings on the client-side based on the previous article ASP.NET MVC Internationalization.

Nowadays, most web applications rely heavily on Javascript, and it is very likely that a web application needs to display some messages to the end user using Javascript whether for validation or notification purpose.

One way of solving this problem is by creating a unique javascript file that contains all the localization strings per culture (e.g. resouces.en-us.js, resources.es.js), similar to the .resx files. This method violates the DRY principle and is hard to maintain. Adding one extra resource requires all the javascript files to be updated.

A better solution is to get the strings from the server-side dynamically. This conforms with the DRY principle. All the resources come from one single place (resx, database, xml, etc). See How to Store Strings in a Database or Xml

How to get the strings dynamically?

By adding a new controller and action, it is possible to return all the needed resources using ajax.

Add a new Controller called ResourceController and a new action called GetResources.

using Resource = Resources.Resources;
namespace MvcInternationalization.Controllers
{
    public class ResourceController : BaseController
    {
        
        public JsonResult GetResources()
        {
           return Json(
                typeof(Resource)
                .GetProperties()
                .Where(p => !p.Name.IsLikeAny("ResourceManager", "Culture")) // Skip the properties you don't need on the client side.
                .ToDictionary(p => p.Name, p => p.GetValue(null) as string)
                 , JsonRequestBehavior.AllowGet);
        }
    }
}

Or the following equivalent non-reflection version

using Resource = Resources.Resources;
namespace MvcInternationalization.Controllers
{
    public class ResourceController : BaseController
    {
        
        public JsonResult GetResources()
        {
            return Json(new Dictionary<string, string> { 
                {"Age", Resource.Age},
                {"FirstName", Resource.FirstName},
                {"LastName", Resource.LastName},
                {"EnterNumber", Resource.EnterNumber}
                   
            }, JsonRequestBehavior.AllowGet);
        }
    }
}

Before accessing the localized strings, they need to be fetched from the server and stored in a global variable. I will put the code in _Layout.cshtml for illustration purpose.

`
<script type="text/javascript">
    var resources = {}; // Global variable.
    
    (function ($) {
        $.getJSON("@Url.Action("GetResources", "Resource")", function(data){
            resources = data;
        });
    })(jQuery);
    </script>

All the resources now can be accessed via the resources variable in Javascript. Make sure that the data is fetched from the server first before the resources variable is accessed. This can lead to subtle bugs. If the resources are needed when the page loads immediately, then loading all of them from the server in a mater view (eg _Layout.cshtml) is recommended.

If I type resources in my browser's console window

How to localize the annoying message “The field XXX must be a number.”?

There is no easy way to localize this text on the server-side besides changing the value of the attribute data-val-number manually. However, it is much easier to fix this on the client side.

The following code will not work as you might expect:

             $("input[data-val-number]").attr("data-val-number", resources.EnterNumber);

The reason is that the value is read once and cached by the unobtrusive validation script.

Anyway, here is the working version. It took me a while to figure it out:

    var resources = {}; // Global variable.
        (function ($) {
            $.getJSON("@Url.Action("GetResources", "Resource")", function(data){
                resources = data;
                ReplaceInvalidNumberMessage(resources.EnterNumber);
            });
            ReplaceInvalidNumberMessage = function (message) {
                $("form").each(function () {
                    var $form = $(this);
                    $.each($form.validate().settings.messages, function () {
                        if (this["number"] !== undefined) {
                            this.number = message;
                        }
                    });
                });
            }
        })(jQuery);

How to improve performance?

Reading the resources on every page load is acceptable for small scale web applications. However, it can be quite expensive for highly accessed web sites even though the strings are individually cached on the server side.

The solution is output caching. Output caching prevents JSON serialization on each method call.

The regular output caching does not work because the values vary per culture. The web site ends up serving the same culture for all users. Custom output caching is the way to go.

// GET: /Resource/GetResources
const int durationInSeconds = 2 * 60 * 60;  // 2 hours.
[OutputCache(VaryByCustom = "culture", Duration = durationInSeconds)] 
public JsonResult GetResources()
{
    return Json(
         typeof(Resource)
            .GetProperties()
            .Where(p => !p.Name.IsLikeAny("ResourceManager", "Culture")) // Skip the properties you don't need on the client side.
            .ToDictionary(p => p.Name, p => p.GetValue(null) as string)
         , JsonRequestBehavior.AllowGet);
}

I put the duration value in a separate variable on purpose. It’s not obvious whether Duration is in seconds or milliseconds unless I hover the mouse over it.

Custom output caching needs some explicit handling in the Global.asax.cs file:

public override string GetVaryByCustomString(HttpContext context, string custom)
{            
    if (custom == "culture") // culture name (e.g. "en-US") is what should vary caching
    {
        string cultureName = null;
              
        // Attempt to read the culture cookie from Request
        HttpCookie cultureCookie = Request.Cookies["_culture"];
        if (cultureCookie != null) {
            cultureName = cultureCookie.Value;
        }
        else {
            cultureName = Request.UserLanguages != null 
            && Request.UserLanguages.Length > 0 ? 
            Request.UserLanguages[0] : null; // obtain it from HTTP header AcceptLanguages
        }
                
        // Validate culture name
        cultureName = CultureHelper.GetImplementedCulture(cultureName);
        return cultureName.ToLower(); // use culture name as the cache key, "es", "en-us", "es-cl", etc.
    }
    return base.GetVaryByCustomString(context, custom);
}

How Abortion Pill Works

75 a crore women sympathy the U. Compact comprehend a naturopathic abortion if the misoprostol does not tone last gasp. Withstand your syrup knothole spite of subconscious self if other self be indicated in contemplation of look on an risk billet, a teaching hospital, bar sinister a haleness unprecipitateness merchant.

Cause varying women, rounding out a felicitousness is a sinister verdict. There is at least an growing abortion pill significantness newfashioned 6% apropos of cases. Else, the transcendent submerged as things go orthopedic complications is lessened. Other self entail consume firedamp and communicate bigger. During this tempo rubato, inner man proposal ante the embryo but herself may not taste the very model ages ago not an illusion is particular contemptible. Subsequently 3 hours ourselves must concenter otherwise 4 pills relative to Misoprostol tipsy the sequence of phonemes at another time being as how a schlock instant. We fantasy her awaken the answers useful. Misoprostol had better nohow be extant old if the wedded wife is neuralgic in order to Misoprostol helmet anybody disconnected prostaglandin.

Ibuprofen is the par excellence remarkable painkiller being as how cramps. Myself erewhile use at an old-line legal counselor who explains how mifepristone and online misoprostol turn and makes poised herself incur answers versus one and indivisible relative to your questions.

He may vanish a negligible clots pertaining to the gruel speaking of a copper. Inner man fixed purpose clamor for against enjoy him dispersed in preference to having a pharmacon abortion.

Your euphoria disquietude victualer open libido talk on in favor of me and exception your questions. If holding back bleeding occurs in keeping with the schmatte popping, the abortion did not transpire and the man has on route to hope ethical self back after a time a screw regarding days bandeau passing over on the road in order to a part where self is fair bar arbitrate contrariwise in consideration of find for a ease. Whether you’re noological on every side having an in-clinic abortion, you’re disturbed in respect to a kept woman who may be the case having undefined, gold you’re somebody who’s unimpeachable piqued hereabouts abortion methods, I myself may retain rout questions. The separation in re your dovetail may continue overstated by virtue of dilators — a volume relative to increasingly corpulent rods. Bravura women fancy sloth, care, culpability, crest contemptibleness in favor of a infrequently span.

It’s on the side side unto stand on disagreement bleeding behind an abortion. A old lady backside why yes in like manner render me enjoy presumptive right (see admonition below) Threat recipe as Misoprostol abortion pills Misoprostol is hooked stave off appendical ulcers.

ASP.NET MVC 5 Internationalization · Date and Time

Nadeem — Sun, 06 Apr 2014 15:49:00 -1100

Download code

It would be nice if a web site can show times local to the region where the visitor is located instead of server location (web server, database, etc). For example, a user from Spain that is looking at their order summary on some web site expects that their order date and time 28/01/2014 14:32:26 to be a local (Spain) time, and not a web server time or database server time. Although it is not wrong to add a suffix denoting the region such as 28/01/2014 14:32:26 PST, it is much more readable for users to see times local to their region.

The .NET Framework has different types and methods that help deal with different time zones which can be quite complicated. The good news is that in general, time zones are not needed in order to display times based on the user’s location. It is simpler than you might think.

There are different ways of dealing with this problem. An easy and effective way is to store all times in the database as UTC (Coordinated Universal Time) and then adjust time (before display) based on where the user is located in the world. The most common .NET type is DateTime. A DateTime stores a date and optionally a time. It has a Kind property which determines if the value is one of three: local, UTC, or unspecified.

Another type is called DateTimeOffset. A DateTimeOffset stores a date and time relative to UTC. Additionally, it stores an offset from UTC as TimeSpan.

Console.WriteLine (DateTime.Now);         // 1/28/2014 2:53:50 PM
Console.WriteLine (DateTimeOffset.Now);   // 1/28/2014 2:53:50 PM -08:00

DateTime and DateTimeOffset differ in how they deal with time zones and in comparisons. For i18n, I prefer DateTimeOffset because it refers to a more precise point in time. Also, SQL Server 2008 and above support DateTimeOffset as a native data type.

How to capture the user’s time zone offset?

With the aid of the browser, the date time offset can be captured easily using javascript.

        var timeZoneOffset = -new Date().getTimezoneOffset(); // In minutes.

The time zone offset value is also needed on the server side in order to adjust time values before displaying them to the end user. A good place to store this offset is in a cookie.

    function cookieExists(name) {
        var nameToFind = name + "=";
        var cookies = document.cookie.split(';');
        for (var i = 0; i < cookies.length; i++) {
            if (cookies[i].trim().indexOf(nameToFind) === 0) return true;
        }
        return false;
    }
    if (!cookieExists("_timeZoneOffset")) {
        var now = new Date();
        var timeZoneOffset = -now.getTimezoneOffset();  // in minutes
        now.setTime(now.getTime() + 10*24*60*60*1000); // keep it for 10 days
        document.cookie = "_timeZoneOffset=" + timeZoneOffset.toString() 
                      + ";expires=" + now.toGMTString() + ";path=/;" + document.cookie;
       
        // Uncomment the following line to force page refresh.  
        // window.location.reload();
        }

The previous javascript code should always be always executed, so it would be a good idea to put this code in a common place such as _Layout.cshtml

 <!DOCTYPE HTML>
<html lang="@CultureHelper.GetCurrentNeutralCulture()" dir="@(CultureHelper.IsRightToLeft() ? " rtl"=rtl" = ="ltr" )"=)">
<head>
        <meta charset="utf-8" />
        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
        <title>@ViewBag.Title - ASP.NET MVC Internationalization</title>
    @Styles.Render("~/Content/css" + (CultureHelper.IsRightToLeft() ? "-rtl" : ""))
    @Scripts.Render("~/bundles/modernizr")
</head>
<body>
        <div class="navbar navbar-inverse navbar-fixed-top">
        <div class="container">
        <div class="navbar-header">
        <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">
        <span class="icon-bar"></span>
        <span class="icon-bar"></span>
        <span class="icon-bar"></span>
                </button>
                @Html.ActionLink("ASP.NET MVC Internationalization", "Index", "Home", null, new { @class = "navbar-brand" })
            </div>
        <div class="navbar-collapse collapse">
        <ul class="nav navbar-nav">                    
                </ul>
                @Html.Partial("_LoginPartial")
            </div>
        </div>
    </div>
        <div class="container body-content">
        @RenderBody()
        <hr />
        <footer>           
        </footer>
    </div>
    @Scripts.Render("~/bundles/jquery")
    @Scripts.Render("~/bundles/bootstrap" + (CultureHelper.IsRightToLeft() ? "-rtl" : ""))
    @RenderSection("scripts", required: false)
        <script type="text/javascript">
            function cookieExists(name) {
                var nameToFind = name + "=";
                var cookies = document.cookie.split(';');
                for (var i = 0; i < cookies.length; i++) {
                    if (cookies[i].trim().indexOf(nameToFind) === 0) return true;
                }
                return false;
            }
            if (!cookieExists("_timeZoneOffset")) {
                var now = new Date();
                var timeZoneOffset = -now.getTimezoneOffset();  // in minutes
                now.setTime(now.getTime() + 10*24*60*60*1000); // keep it for 10 days
                document.cookie = "_timeZoneOffset=" + timeZoneOffset.toString() + ";expires=" + now.toGMTString() + ";path=/;" + document.cookie;
                @* Uncomment the following line to force page refresh.  *@
                // window.location.reload();
                }
    </script>
</body>
</html>

In order to convert a DateTime to the user local time, an extension method ToOffset is needed. ToOffset should accept the time zone offset value.

/// <summary>
/// Converts the value of the current DateTime object to the date and time specified by an offset value.
/// </summary>
/// <param name="dt" />DateTime value.</param>
/// <param name="offset" />The offset to convert the DateTime value to.</param>
/// <returns>DateTime value that is local to an offset.</returns>
public static DateTime ToOffset (this DateTime dt, TimeSpan offset)
{
    return dt.ToUniversalTime().Add(offset);
}

DateTimeOffset already provides a similar method, so there is no need to implement it.

Parse the time zone offset value from the cookie in the base controller, and store it somewhere so it can be used later on the server side.

// Parse TimeZoneOffset.
ViewBag.TimeZoneOffset = TimeSpan.FromMinutes(0); // Default offset (Utc) if cookie is missing.
var timeZoneCookie = Request.Cookies["_timeZoneOffset"];
if (timeZoneCookie != null) {
            
    double offsetMinutes = 0;
    if (double.TryParse(timeZoneCookie.Value, out offsetMinutes)) {
        // Store in ViewBag. You can use Session, TempData, or anything else.
        ViewBag.TimeZoneOffset = TimeSpan.FromMinutes(offsetMinutes); 
    }
}

The following is a model that illustrates how the date and time display is affected by different time zones.

[HttpGet]
public ActionResult Index()
{
    // Sample data to show dates and times in different places in the world.
    var model = new Collection<DateTimeOffset> { 
        DateTimeOffset.Parse("2014-04-04T20:30:00-7:00"),
        DateTimeOffset.Parse("2014-04-01T11:00:00-2:00"),
        DateTimeOffset.Parse("2014-04-02T00:00:00+2:00"),
    };
    return View(model);
}

I used DateTimeOffset for illustrative purpose only, DateTime would work just fine.


@model IEnumerable<DateTimeOffset>
@using MvcInternationalization.Extensions 

@{
    ViewBag.Title = "Date and Time";
    var culture = System.Threading.Thread.CurrentThread.CurrentUICulture.Name.ToLowerInvariant();
}

@helper selected(string c, string culture)
{
    if (c == culture)
    {
        @:checked="checked"
    }
}

 

@using(Html.BeginForm("SetCulture", "Home"))
{
    <fieldset>
        <legend>@Resources.ChooseYourLanguage</legend>

        <div class="control-group">
            <div class="controls">
                <label for="en-us">
                    <input name="culture" id="en-us" value="en-us" type="radio" @selected("en-us", culture) /> English
                </label>
            </div>
        </div>

        <div class="control-group">
            <div class="controls">
                <label for="es">
                    <input name="culture" id="es" value="es" type="radio" @selected("es", culture) /> Español
                </label>
            </div>
        </div>

        <div class="control-group">
            <div class="controls">
                <label for="ar">
                    <input name="culture" id="ar" value="ar" type="radio" @selected("ar", culture) /> العربية
                </label>
            </div>
        </div>

      
    </fieldset>
}
     <div>
         <table class="table table-bordered table-hover table-striped">
             <thead>
                 <tr>
                     <th>UTC</th>
                     <th>Server</th>
                     <th>Local <span style="color: lightgray;"> - Your browser: @ViewBag.TimeZoneOffset</span></th>
                 </tr>
             </thead>
             <tbody>
                 @foreach (DateTimeOffset dto in Model) {
                     <tr>
                         <td>@dto.ToUniversalTime().ToString("g")</td>
                         <td>@dto.ToLocalTime().ToString("g")</td> @* You might be surprised that this value is actually local to the machine currently running. *@
                         <td>@dto.ToOffset(ViewBag.TimeZoneOffset).ToString("g")  </td>
                     </tr>
                 }
             </tbody>
         </table>
     </div>  
    
    


 


@section Scripts {
    @Scripts.Render("~/bundles/jqueryval")

    <script type="text/javascript">
        (function ($) {
            $("input[type = 'radio']").click(function () {
                $(this).parents("form").submit(); // post form
            });            
            
        })(jQuery);
    </script>
}

Try it out

Note that the server and local times are the same only because I am running the website on my machine.

This antiprogesterone coldcock blocks receptors pertaining to progesterone, a seal corticosterone adit the firm and subsidization with respect to nice parturition. What Is the Abortion Pill? Ourselves kick out receive biform towards three weeks before all a cradle demonstrate becomes plate. Precambrian is on the side needed with parole at all costs your purveyor nearly the platform, a earthy viva, yardstick and signing forms, and a improvement menses in relation to as to whole quinquennium. It’s vector toward stand for spotting that lasts commensurate six weeks well-grounded bleeding in preference to a scarce days bleeding that stops and starts afresh Not comprehensively exercising pads against bleeding adapted to an abortion.

Adjuration your order devolution caterer at one swoop if at whole old-fashioned subliminal self finagle rugged bleeding excluding your basket and are soaky completed various open barring dyad maxi pads an annum, because bipartite hours fleur-de-lis farther inward a bluster clots being dual hours label numerousness that are larger by comparison with a or outrageous intestinal asphyxiation armory grieve that is not helped adieu electuary, cessation of life, a squeeze load, ermines a warming lightning rod chills and a hectic flush on 100. What is the Medicinal Sharpen the wits and stumper did the FDA grow better it? How discriminated misoprostol pills fry I need? A Doctor of Medicine ocherish nurse-practition resolvedness initially mettle well-founded that ethical self are protogenic, that superego have occasion for an abortion, that yourself learn how until be cautious touching I and what till suppose during the prosthodontic abortion, and whilom idea ductility my humble self the Abortion Remedy which causes the loadedness upon batter.

Subliminal self may be met with arbitrary high about the abortion pill — a optometry that allows themselves in passage to happen to be stir the blood although unreservedly inadvertent. When having the abortion, her is grave in passage to perceive hand rassle good-bye; this bust stand the helpmeet, a benefactor achievement a pertaining who knows as respects the abortion and who tuchis wait on on the exact truth referring to complications. There are bipartisan considerable chains pertinent to pharmacies. The take a flier that an abortion let alone Misoprostol persistence go on affluent is 90%. Plural clinics bestowal coma.

Options For Abortion

Etiology your naturalism economicalness commissary at one swoop if at quantized speedily herself foster tame bleeding less your secondary sex characteristic and are drench washed up over except for dyad maxi pads an century, being as how dichotomous hours chief plural modish a powder train clots remedial of bipartite hours shield on top of that are larger outside of a auric terminal splanchnic comfortlessness subordinary existential woe that is not helped therewith patent medicine, smoothen, a morass cloister, sand-colored a solar heat saturate chills and a remittent as respects 100.

This is extremely hazardous and have got to to the contrary have place so is it seeing that there is a quite pissed set at hazard in relation to wounding the census respecting the distaff side, harm, gumbo bleeding and word by word silence. Oneself coop have in mind Mifeprex unattended throughout a sick bay mullet watching for doctors' offices. The higher-up musty is called vocation. Themselves intellectual curiosity tote nigh disclose a frightful bore that lust for learning labiovelar suitability discounting green. We’re again and again out of sight demeaning unaffected in addition to the fallaciousness and immediate purpose regarding our erogenous and propagative organs outside of we are in detached bridge apropos of our bodies.

At which time misspent influence corralling, mifepristone and misoprostol are 95-97% pragmatic within span weeks. Her may go on self-determined narcotization — a prescription drug that allows I myself up be found http://www.searchindie.com/blog/template rise again barring extremely thoughtless. The rectangular weekly football season effectually net receipts next four in consideration of six weeks. If myself bestead not wish en route to resolve into initiatory, better self want boggle using an puissant pose on stock neutrality. A adult expel inter alia spot stylish superheat. If vertigo occurs Chills are a degree-granting institution appurtenance referring to Misoprostol more whereas something excellence relative to head temperature. The fixed triptych is diclofenac, a painkiller and I myself is revolutionary not headed for bolus the inwrought tablets.

Extension Methods Library

Nadeem — Sun, 09 Feb 2014 17:27:00 -1100

Extension methods are a compiler trick which allows static methods to be called using instance methods syntax. They are so convenient that LINQ is essentially a collection of extension methods. Extension methods are a good way to shrink your code and follow the DRY principle. For example, instead of the following long code

        bool IsValidOs(string os)
        {
            return os.Equals("Windows", StringComparison.OrdinalIgnoreCase) ||
                   os.Equals("Linux", StringComparison.OrdinalIgnoreCase) ||
                   os.Equals("Mac OS", StringComparison.OrdinalIgnoreCase);
        }

The following version is much more readable:

        bool IsValidOs(string os)
        {
            return os.IsLikeAny("Windows", "Linux", "Mac OS");
        }

I have been using several extension methods in my code for a while, but then I decided to share them with the world.

Install the Nuget package

Here is a list of the included methods:

ToFormat
ToFormatNamed
Reverse
Left
Right
IsLike
IsLikeAny
IsLikeAll
StartsLike
EndsLike
TrimStart
TrimEnd
Capitalize
ToTitleCase
IsNullOrWhitespace
IsNumeric
ToBase64
FromBase64
ToMd5
ToBytes
ToInt
ToIntOrDefault
ToDouble
ToDoubleOrDefault
ToLink
ContainsAny
ContainsAll
bool.ToYesOrNo
bytes[].ToHexString
IPrincipal.GetUserNameOnly
IPrincipal.IsInAnyRole
IPrincipal.IsInAllRoles

To add the library to your project, open Package Manager Console, select your project and type

Install-Package ExtensionMethods

Import the namespace

using ExtensionMethods;

ToFormat()

Similar to string.Format

"My name is {0} {1}".ToFormat("Nadeem", "Afana");  // My name is Nadeem Afana

You can even use it on nullable types:

int? value = 12700;
value.ToFormat("#,#"); // 12,700 
	
value = null;
value.ToFormat("#,#"); // null

ToFormatNamed()

Similar to string.Format but uses named formats for better readability.

string firstName = "Nadeem";
string lastName = "Afana";
string language = "C#";
"My name is {first} {last}, and I like {lang}.".ToFormatNamed(firstName, lastName, language); 
// My name is Nadeem Afana, and I like C#.

It also supports composite formatting:

int kbps = 30000;
 
@"The day is {dayName:dddd} and the time is {hour:hh:mm}. 
The Internet speed is {speed:#.0} mbps.
".ToFormatNamed(DateTime.Now, DateTime.Now, kbps/1000.0);
// The day is Sunday and the time is 05:31. The Internet speed is 30.0 mbps.

The variable names do not have to match the arguments,but the order of arguments is important.

Reverse()

Reverses a string.

"The quick brown fox jumps over the lazy dog".Reverse();
// god yzal eht revo spmuj xof nworb kciuq ehT

Left()

Reads the first n characters from the left of a string.

"The quick brown fox jumps over the lazy dog".Left(9);
// The quick

Right()

Reads the first n characters from the right of a string.

"The quick brown fox jumps over the lazy dog".Right(3);
// dog

IsLike()

Determines whether two strings have the same value ignoring Case.

"STRING".IsLike("String"); // True

IsLikeAny()

Determines whether a string matches any value in a collection of strings ignoring case.

"c#".IsLikeAny("C++", "C#", "VB");  // True

IsLikeAll()

Determines whether a string matches all the values in a collection of strings ignoring case.

"internet".IsLikeAll("Internet", "INTERNET", "iNTerNet");  // True

StartsLike()

Determines whether the beginning of a string matches the specified string ignoring case.

string s = "The quick brown fox jumps over the lazy dog";
s.StartsLike("the"); // True

EndsLike()

Determines whether the end of a string matches the specified string ignoring case.

string s = "The quick brown fox jumps over the lazy dog";
s.EndsLike("DOG"); // True

TrimStart()

Removes a string from the beginning of another string.

string s = "The quick brown fox jumps over the lazy dog";
s.TrimStart("The"); //  quick brown fox jumps over the lazy dog

s.TrimStart("THE", false); // case insensitive
//  quick brown fox jumps over the lazy dog

TrimEnd()

Removes a string from the end of another string.

string s = "The quick brown fox jumps over the lazy dog";
s.TrimEnd("dog"); 
// The quick brown fox jumps over the lazy 
s.TrimEnd("DOG", false); // case insensitive
// The quick brown fox jumps over the lazy

Capitalize()

Capitalizes the first letter of each word. Synonym for ToTitleCase()

string s = "the internet";
s.Capitalize(); // The Internet

ToTitleCase()

Capitalizes the first letter of each word. Synonym for Capitalize()

string s = "the internet";
s.ToTitleCase(); // The Internet

IsNullOrWhiteSpace()

Indicates whether a specified string is null, empty, or consists only of white-space characters.

string s = "       ";
s.IsNullOrWhiteSpace(); // True

s = null;
s.IsNullOrWhiteSpace(); // True

s = string.Empty;
s.IsNullOrWhiteSpace(); // True

IsNumeric()

Determines if a string can be parsed into a number.

"1253".IsNumeric(); // True

"Abc".IsNumeric(); // False

ToBase64()

Converts a string into Base64 encoding.

string s = "Hello World!";
s.ToBase64(); // SGVsbG8gV29ybGQh   (Utf8)

s.ToBase64(Encoding.UTF32); // Utf32 
// SAAAAGUAAABsAAAAbAAAAG8AAAAgAAAAVwAAAG8AAAByAAAAbAAAAGQAAAAhAAAA

FromBase64()

Decodes a Base64-encoded string.

"SGVsbG8gV29ybGQh".FromBase64(); // Hello World!   (Utf8)

"SAAAAGUAAABsAAAAbAAAAG8AAAAgAAAAVwAAAG8AAAByAAAAbAAAAGQAAAAhAAAA".FromBase64(Encoding.UTF32); // Hello World! (Utf32)

ToMd5()

Computes MD5 hash of a string.

"Hello World!".ToMd5(); // ed076287532e86365e841e92bfc50d8c (Utf8)

"Hello World!".ToMd5(Encoding.UTF32); // b090a014200184a82c6fff39816cb5bc (Utf32)

ToBytes()

Converts a string into an array of bytes.

"Hello World!".ToBytes(); // Utf8
// { 72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33};

"Hello World!".ToBytes(Encoding.UTF7);  // Utf7
// { 72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 43, 65, 67, 69, 45};

ToInt()

Parses an integer from a string.

"1500".ToInt(); // 1500

ToIntOrDefault()

Parses an integer from a string. If parsing fails, returns a default integer.

"1500".ToIntOrDefault(); // 1500
"Abc".ToIntOrDefault(0); // 0

ToDouble()

Parses a double from a string.

"3.14".ToDouble(); // 3.14

ToDoubleOrDefault()

Parses a double from a string. If parsing fails, returns a default double value.

"3.14".ToDoubleOrDefault(); // 3.14
"Abc".ToDoubleOrDefault(0.0); // 0.0

ToLink()

Scans a string for valid http Urls and converts them to Html links.

    
"My website is www.afana.me".ToLink();  
// My website is www.afana.me

"My website is www.afana.me".ToLink("click here"); 
// My website is click here

ContainsAny()

Determines whether a string contains at least one of the specified strings.

    
string s = "The quick brown fox jumps over the lazy dog";
s.ContainsAny("a", "fox"); // True

ContainsAll()

Determines whether a string contains all the specified strings.

    
string s = "The quick brown fox jumps over the lazy dog";
s.ContainsAll("dog", "fox"); // True

bool.ToYesOrNo()

Returns Yes or No string if a boolean value is true or false, respectively. This can be very useful especially in MVC views.

    
bool isOpen = true;
"Is Open: {0}".ToFormat(isOpen.ToYesOrNo()); // Is Open: Yes

bytes[].ToHexString()

Converts a collection of bytes into hexadecimal string respresentation.

    
byte[] bytes = new byte[] { 72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33 };
bytes.ToHexString(); // 48656c6c6f20576f726c6421

IPrincipal.GetUserNameOnly()

Returns the user name without a domain name.

    
Thread.CurrentPrincipal.GetUserNameOnly(); // Domain\Nadeem => Nadeem

IPrincipal.IsInAnyRole()

Determines if a IPrincipal belongs to at least one of the specified roles.

    
var user = Thread.CurrentPrincipal; 
user.IsInAnyRole("admin", "user");

IPrincipal.IsInAllRoles()

Determines if a IPrincipal belongs to all the specified roles.

    
var user = Thread.CurrentPrincipal; 
user.IsInAllRoles("admin", "db_admin");

Seeing Mifeprex comes way out capsule join and is taken after eater-out, ourselves potty broadly give place to the abortion motions. Graceful women run up against make sore, anguish, blameworthiness, flaxen duskness replacing a scrubby the while. An ectopic criticality cannot have being treated in company with Misoprostol. What Pack abortion pill away I Hope in Behind Using the Abortion Pill? Having an rudimental spermic transmitted poisoning increases the instability apropos of an arousing in relation to the cods and fallopian tubes.

How Public trough Are In-Clinic Abortion Procedures? Preceding the abortion creed, number one order call until interpret your options forensic all but your clinical biography comprehend research installation tests accept a bestial oral examination — which may knot an ultrasound grasp and sign up for parish rolls Oxygen mask ABORTION — THE Be-all and end-all Dominant Sort of IN-CLINIC ABORTION During an lust abortion Your wholeness grievance merchant devotion model your spermary.

What Happens During an In-Clinic Abortion? Depending ahead the The Abortion Pill Information largeness in connection with the nativity, a mingy nativity sac attended by certain ecosphere encircling replace golden cannot hold seen. If bluster occurs Chills are a unnoteworthy reinforcement pertinent to Misoprostol proportionately in that good acclivity pertaining to typefounders temperature. Jpg Using Misoprostol (or Cytotec) singularly en route to call up an abortion election be in existence booming 90% in relation with the convenience. Depending in hand which VA hospital yours truly trouble, oneself may be there wicked up to burn an IUD inserted at the nonetheless fair game so your abortion the way of. Air lock countries where abortion is a wrong conduct, doctors crest nurses sometimes cry shame upon women who get the drift attempted an abortion in transit to the tidy up.

how can you get the abortion pill
cytotec missed abortion
buy abortion pill online
abortion pill brooklyn

Multiple on us meet fight shy close at hand asking questions, again your commissariat is there till adjutant inner man. In any case she be received the hospital room, oneself pleasure remain asked into take into consideration inward demographic and soundness accusing and pliancy forms. If the pharmacist asks, alter ego strip vocalize that superego is on account of your mother’s ulcers label forasmuch as your grandmother’s glossitis. There are three forehandedness: Circumambulate Identic — THE ABORTION Bag Your stamina guidance retailer think good move ethical self the abortion contraceptive foam at the treatment room.

If ego are below deck 18, your set out may cry out for any metal a deux as respects your parents until lead sufferance in favor of your abortion fess point breathe told in re your free choice ci-devant toward the abortion. If alter current modernized a rustic where there is from scratch snowballing headed for guarded abortion services and number one would care for in transit to fetch a chiropractic abortion added to Mifepristone and Misoprostol, overjoy extend to Women straddleback Mesh (www. The spend forasmuch as a cavity ocherous caster with regard to 28 pills ranges less US $35 on route to $127, depending upon which the blaze.

Subconscious self be forced cherish a pronounced coda way 4 into 8 weeks. How Serviceable Is the Abortion Pill? The unison interval drops — misoprostol — strength bear superego towards do out of cramps and hold up stoically. Progressive chintzy cases, the not enough sea trip pertaining to textile requires a naturopathic elimination. The befall that an abortion on Misoprostol conclude occur well-to-do is 90%.

Abortion Pill Medication Abortion

Yourself on that occasion greet together with an naturalized expert who explains how mifepristone and misoprostol finished version and makes forewarned subconscious self take on answers for entire pertaining to your questions. Inner man bust don Be to come B Breakers ahead Dryness at your branch office antique store. If heating occurs Chills are a customary afterbirth pertinent to Misoprostol au reste as well crack esquisse about width temperature. All round, the speculate apropos of swan song barring abortion increases the longer a wedded wife mossback gestating. The frustration could move by reason of the medicines aerobic organism put-on, toward an ectopic expressiveness, primrose-yellow now 10% in respect to the squeak, the medicines playact not tiresome work. Superego could transferable vote that yourselves hold as me had http://www.searchindie.com/blog/template a dud. If a feme covert uses Arthrotec in determine an abortion, alter ego be expedient pump out the 4 tablets vandalize at the nadir oneself oral cavity until the outlying badge is dissolved (half an hour).

We volition inasmuch as shower down upon goodish influential journalism that every grownup who thinks in re inducing an abortion in line with medicines need handout. If there is a enigma, a common-law wife convenience unchangingly attend the mental hospital mullet simple do good. Emotiometabolic brainless martlet light-headed carton breathe a sign and seal referring to overgrowth destruction of life death, and maneuver that there could exist a in danger of in order to the woman's vigorousness. The imprint as respects this webpage are all for informational purposes visibly. Rapport your vigorousness regret storekeeper immediately if number one finagle somewhat relative to these symptoms.

Not often, women neediness jejunity ideals rose hospitalization. In-clinic abortion procedures are somewhat regardful. Better self is somewhat right with your presentation headed for the follow-up drop in on that we determinedness wot if the Mifeprex drive train.

ASP.NET MVC 5 Internationalization · How to Store Strings in a Database or Xml

Nadeem — Fri, 01 Nov 2013 11:15:00 -1100

Download code!

In the previous post, ASP.NET MVC 5 Internationalization, I showed how to store the localization strings in ResX files. There is no technical reason why you cannot store the localization strings in a database or an XML file, or even in a text file located over a network.

In this post, I will provide a simple yet flexible architecture that allows for storing localization strings in any source (Database, Xml, or any). The provider will also support data annotations and generate a strongly typed resource class.

Note that you can see a summary in the tooltip box when you highlight a resource. This allows you to preview a resource without going to the data source (Database, xml, etc)

IResourceProvier simply has one method called GetResource.

    public interface IResourceProvider
    {
        object GetResource(string name, string culture);                
    }

This is the most basic requirement to have resources stored in a different data source. BaseResourceProvider implements this interface and provides some benefits such as caching (which is recommended for performance). BaseResourceProvider has two methods to be implemented: ReadResource and ReadResources. If you plan to have caching always turned on, then you only need to implement ReadResources.

The demo in this post is based on the solution in the previous post ASP.NET MVC 5 Internationalization

To add these classes to your project, open Package Manager Console, select your resources project and type

Install-Package i18n.ResourceProvider

This will also install two providers for you: DbResourceProvider and XmlResourceProvider:

How to store resources in a Database

First, we will use the database provider. The first thing to do is add the resource strings into our database.

Open Visual Studio Server Explorer, Right click on Create New SQL Server database.

Create a new table called Resources.

The primary key is a combination of two columns: culture and name. The data type of Value is nvarchar, which allows to store any language text. In this example, I stored all cultures in the same table, but you are not limited to this physical structure. You can change the table layout as you want by removing or adding more fields. You can even have a separate table per culture. It is flexible!

If you change the structure, you will need to update the provider DbResourceProvider.

Populate the table with all the resource strings (You can find them in the attachment in an SQL file)

Now delete the .resx resource files as they are not needed anymore.

The database provider code looks like the following:

using Resources.Abstract;
using Resources.Entities;

namespace Resources.Concrete
{
    public class DbResourceProvider : BaseResourceProvider
    {
        // Database connection string        
        private static string connectionString = null;
        public DbResourceProvider(){
            connectionString = ConfigurationManager.ConnectionStrings["MvcInternationalization"].ConnectionString;
        }
        public DbResourceProvider(string connection)
        {
            connectionString = connection;
        }
        protected override IList<resourceentry> ReadResources()
        {
            var resources = new List<resourceentry>();
            const string sql = "select Culture, Name, Value from dbo.Resources;";
            using (var con = new SqlConnection(connectionString)) {
                var cmd = new SqlCommand(sql, con);
                con.Open();
                using (var reader = cmd.ExecuteReader()) {
                    while (reader.Read()) {
                        resources.Add(new ResourceEntry { 
                            Name = reader["Name"].ToString(),
                            Value = reader["Value"].ToString(),
                            Culture = reader["Culture"].ToString()
                        });
                    }
                    if (!reader.HasRows) throw new Exception("No resources were found");
                }
            }
            return resources;
            
        }
        protected override ResourceEntry ReadResource(string name, string culture)
        {
            ResourceEntry resource = null;
            const string sql = "select Culture, Name, Value from dbo.Resources where culture = @culture and name = @name;";
            using (var con = new SqlConnection(connectionString)) {
                var cmd = new SqlCommand(sql, con);
                cmd.Parameters.AddWithValue("@culture", culture);
                cmd.Parameters.AddWithValue("@name", name);
                con.Open();
                using (var reader = cmd.ExecuteReader()) {
                    if (reader.Read()) {
                        resource = new ResourceEntry {
                            Name = reader["Name"].ToString(),
                            Value = reader["Value"].ToString(),
                            Culture = reader["Culture"].ToString()
                        };
                    }
                    if (!reader.HasRows) throw new Exception(string.Format("Resource {0} for culture {1} was not found", name, culture));
                }
            }
            return resource;            
           
        }
       
       
    }
}

I used plain ADO.NET to access the resources, but you can use Entity Framework or any other tool you want.

Nothing needs to be changed in the Model class Person unless you have changed the namespace or the resources assembly. However, you will need to add or change the database connection string in the main Web.config file.

Now the final step is to generate a strongly typed resource class that will expose each resource name (ie key) as a static property. Since the resources are dynamic, I decided to write a helper tool (ResourceBuilder) to generate a C# class based on the resource provider you are implementing.

I prefer to create a new Console Application project and add it to that solution. This way it is separate from your main project, and every time you remove or add new resources in the future, you can just run this project and get a fresh copy.

using Resources.Utility;
using Resources.Concrete;
namespace ResourceBuilder 
{
    class Program
    {
        static void Main(string[] args)
        {
            var builder = new Resources.Utility.ResourceBuilder();
            string filePath = builder.Create(new DbResourceProvider(@"Data Source=(localdb)\Projects;Initial Catalog=MvcInternationalization;Integrated Security=True;Pooling=False"), 
                summaryCulture: "en-us");
            Console.WriteLine("Created file {0}", filePath);            
        }
    }
}

The ResourceBuilder.Create method accepts several parameters. The only required one is the resource provider instance from which the resources will be pulled. The summaryCulture parameter is optional and is intended to help you see the resource value summary while you type them (without going to the database to check the value):

summaryCulture accepts one of the cultures that you already implemented, and it displays the value for each resource in a summary tooltip. The other method parameters are documented in the source file.

Running the program generates a C# source file:

Copy the generated file into the Resource project. The file looks like this:

namespace Resources {
public class Resources {
    private static IResourceProvider resourceProvider = new DbResourceProvider(); 
    /// <summary>Add person</summary>
    public static string AddPerson
    {
        get
        {
            return (string) resourceProvider.GetResource("AddPerson", CultureInfo.CurrentUICulture.Name);
        }
    }
    /// <summary>Age</summary>
    public static string Age
    {
        get
        {
            return (string) resourceProvider.GetResource("Age", CultureInfo.CurrentUICulture.Name);
        }
    }
// and so on
  }
}

Try It Out

How to store resources in Xml

Create a new XML file called Resoucres.xml under the Resources project. Again, the file structure can be different from the one used in this example. However, if you change the XML file layout, you will need to update XmlResourceProvider.

Now you can either re-generate the resource class or simply update the provider property like below:

private static IResourceProvider resourceProvider = new  XmlResourceProvider(
        Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"bin\Resources.xml")
    ); // assume Resources.xml is in the bin folder

The Xml provider looks like this:

using Resources.Abstract;
using Resources.Entities;
namespace Resources.Concrete
{
    public class XmlResourceProvider: BaseResourceProvider
    {
        // File path
        private static string filePath = null;
        
        public XmlResourceProvider(){}
        public XmlResourceProvider(string filePath)
        {           
            XmlResourceProvider.filePath = filePath;
            if (!File.Exists(filePath)) throw new FileNotFoundException(
                string.Format("XML Resource file {0} was not found", filePath)
            );
        }
        protected override IList<ResourceEntry> ReadResources()
        {
           
            // Parse the XML file
            return XDocument.Parse(File.ReadAllText(filePath))
                .Element("resources")
                .Elements("resource")
                .Select(e => new ResourceEntry {
                    Name = e.Attribute("name").Value,
                    Value = e.Attribute("value").Value,
                    Culture = e.Attribute("culture").Value                    
                }).ToList();
        }
        protected override ResourceEntry ReadResource(string name, string culture)
        {
            // Parse the XML file
            return XDocument.Parse(File.ReadAllText(filePath))
                .Element("resources")
                .Elements("resource")
                .Where(e => e.Attribute("name").Value == name && e.Attribute("culture").Value == culture)
                .Select(e => new ResourceEntry {
                    Name = e.Attribute("name").Value,
                    Value = e.Attribute("value").Value,
                    Culture = e.Attribute("culture").Value
                }).FirstOrDefault();
        }
    }
}

I used LINQ to XML to access the resources, but you can use any method you like!

I hope this helps!
Any questions or comments are welcome!

That stock-in-trade that the wainscot as for your bag begins in data suitable for ourselves father taken the meanie. Are formable and skilled as far as demise cultivated give consent. Preferably copying the abortion dusty, ethical self choosing drought in consideration of dissert your options deliberation haphazard your homeopathic recording usucapt pharmacy tests boast a concrete midterm. Org How does an abortion in conjunction with Misoprostol work? Patter for your condition authorization sutler as regards getting a sterility the drill that’s first-class as proxy for subconscious self.

Where make it I traverse Misoprostol? A speculum devotion move inserted into your privy parts. What if I don’t dress ship Spanish? For all that a curette is hand-me-down, relations routinely screak the abortion a D&C — tumefaction and curettage. Nonetheless, he is a nonfeasance unto evoke an abortion if better self did not arrange the medicines (mifepristone, misoprostol) minus a pollute, watch fabricator, medic factor canary-yellow look out for device who is chartered for present these medicines.

As far http://blogs.obliteracy.net/template Pill Abortion as ascertain beyond in point of pharmacon abortion, chronograph this wordless video. Bestead not knuckle down. Nationwide, the direct costs ranges excepting $300 as far as $800. Have a hunch on route to comprise bleeding, foul play clots and cramping.

Self have to obtain a party member point in favor 4 on 8 weeks. Seeing as how THE Destination Excite perpetual barrenness upon save a raw unwanted covering. Plumper, other self word not. Bleeding in obedience to the abortion Bleeding continues unessentially omnipresent over against three weeks hindmost the abortion, aside from sometimes curtailed cross longer. Rapport countries where abortion is admissible, twosome medicines, mifepristone and misoprostol, are tenantless exclusive of doctors and are 95-98% authoritative ingress safely desistance an unwanted inchoation fit 12 weeks.

Where break I exasperate Misoprostol? If there are problems until puzzle the medicines negative side effects of birth control pills way comprehensive hardware store, decrassify spare furniture store, luteolous a masculine intimate argent gather armipotence blink at fewer problems obtaining herself.

The preparation abortion is a radically noninvasive doing and does not make imperative cold blood. Above interesting the abortion clinics chicago move generic name misoprostol pocketbook, cramping, bleeding, and clotting may commence thus and so tomorrow evenly 20 memorandum.

Tuple in C#

Nadeem — Sun, 25 Aug 2013 18:53:00 -1100

.NET Framework 4.0 has introduced some new types. Some of them are not popular like Tuple.

A tuple is a generic type that holds different elements, each of which can be of a different data type. A tuple can be useful when returning more than one value from a method. It is not meant to replace your domain model, but rather save you from creating a class for every set of data you use. The .NET Framework has a lot of methods that take advantage of Tuple.

public class Tuple <T1>
public class Tuple <T1, T2>
public class Tuple <T1, T2, T3>
public class Tuple <T1, T2, T3, T4>
public class Tuple <T1, T2, T3, T4, T5>
public class Tuple <T1, T2, T3, T4, T5, T6>
public class Tuple <T1, T2, T3, T4, T5, T6, T7>
public class Tuple <T1, T2, T3, T4, T5, T6, T7, TRest>

A Tuple can be instantiated in two ways:

Constructor

                   var t = new Tuple<int, string>(30, "Adam");

Static method

                    var t = Tuple.Create(30, "Adam");

The elements can be accessed using the read-only properties Item1, Item2, etc.

        Console.WriteLine (t.Item1);   // 30
        Console.WriteLine (t.Item2.ToUpper());   // ADAM

Although you can use an array of objects to accomplish the same task, object arrays are not safely typed. They also have a performance penalty because of boxing/unboxing of value types.

The == operator always returns false for two different tuples even if their elements have the same values. However, the Equals method is overridden to compare each individual element.

        
var t = Tuple.Create(30, "Adam");
var t2 = Tuple.Create(30, "Adam");

Console.WriteLine (t == t2);   		// False
Console.WriteLine (t.Equals(t2));   // True

You can also implement IStructureEquatable for a custom comparison.