USE AdventureWorks2012; GO EXEC sp_recompile N'Sales.Customer'; GO
https://msdn.microsoft.com/en-us/library/ms190439.aspx
[Required]
[StringLength(255, MinimumLength=8)]
[DataType(DataType.Password)]
[RegularExpression(@"^(?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[^\da-zA-Z])(.{8,15})$", ErrorMessage = "Password must contain at least 1 number, 1 uppercase letter, and 1 special character.")]
public string Password { get; set; }
^ #Beginning of expression (?=.*\d) #At least one digit (?=.*[a-z]) #At least one lower case (?=.*[A-Z]) #At least one upper case (?=.*[^\da-zA-Z]) #A non-alphanumeric character (.{8,15}) #Allow between 8 and 15 characters $ #End of expression
Good website to find a starting point for Regular Expression: http://regexlib.com/
Volume Down key.Android recovery text, press the Volume Up key to put XOOM tablet in recovery mode. After a few min, you should see a Green Android laying down with the triangle and an exclamation (Android recovery screen).Power button then press and release the Volume Up key. This will take you to the recovery screen with list of menus.Volume Down key navigate to Wipe data / factory reset option and press Power button to select it.Yes, delete all user data option using Power buttonvar age = 30;
Implicitly Typed Arrays
var numbers = new[] { 1, 2, 3, 4, 5};
var names = new[] { "Dave", Doug, "Jim" };
old:
public int ID
{
get{return _id;}
set{_id = value;}
}
public int ID { get; set; }
Object Initializers
Person obj = new Person();
obj.ID = 1;
obj.FirstName = "Thiru";
obj.LastName = "Thangarathinam";
new:
Person obj = new Person { ID = 1, FirstName = "Thiru", LastName = "Thangarathinam" };
Collection Initializers
List names = new List();
names.Add("David");
names.Add("Tim");
names.Add("Doug");
new:
List names = new List {"David", "Tim", "Doug"};
Anonymous Types
As the name suggests, anonymous types allow you to create a type on-the-fly at compile time. The newly created type has public properties and backing fields defined for the members you initialize during construction. For example, consider the following line of code:
var obj=new{ID=1,FirstName="Thiru",LastName="Thangarathinam"};
In the above line, you just specify the various attributes you want to have in the anonymous class and assign the instantiated object to a variable of type "var". The actual type assigned to obj is determined by the compiler. Since the compiler assigns the name of the type only at compile time, you can't pass an anonymous type to another method and it can only be used within the method they were declared.
When the compiler sees the above code, it automatically declares a class as follows:
class __Anonymous1
{
private int _id = 1;
private string _firstName = "Thiru";
private string _lastName = "Thangarathinam";
public int ID
{
get{return _id;}
set{_id = value;}
}
public string FirstName
{
get{return _firstName;}
set{_firstName = value;}
}
public string LastName
{
get{return _lastName;}
set{_lastName = value;}
}
}
Anonymous Types use the Object Initializer to specify what properties the new type will be declare. This allows us to reduce code looking similar to this:
Note that the anonymous types are just meant to be placeholders for quickly defining entity types and you can't add methods or customize the behavior of an anonymous type.
Another important feature introduced with C# is the ability to add new static methods to existing classes, known as extension methods. Using this new feature, you can extend the built-in classes (such as the String class) to support your custom requirements. For example, you can add a new method named "IsValidZipCode" to the string class that validates the zip code format. Let us discuss the code required to accomplish this:
namespace StringExtensions
{
public static class CustomStringExtension
{
public static bool IsValidZipCode(this string input)
{
Regex regEx = new Regex(@"^\d{5}$");
return regEx.IsMatch(input);
}
}
}
As part of the declaring the arguments for the IsValidZipCode, you specify the name of the type to which the extension method should be added as the first parameter. In this case, since we want the IsValidZipCode method to be added to the string class, you specify string as the first parameter. Once you are inside the IsValidZipCode() method, you can access all of the public properties/methods/events of the actual string instance that the method is being called on. In this example, you return true or false depending on whether it is a valid zip code or not.
Now that you have implemented the extension method, the next step is to invoke it from the client application. To be able to do that, you first need to import the namespace in which the CustomStringExtension is located.
using StringExtensions;
Once you have imported the namespace, the next step is to declare a variable of type string and invoke the IsValidZipCode() method.
private void btnTestExtensionMethod_Click(object sender, EventArgs e)
{
string zip = "85226";
if (zip.IsValidZipCode())
MessageBox.Show("Valid Zipcode format");
else
MessageBox.Show("Invalid Zipcode format");
}
As you can see from the preceding lines of code, the extension methods allow you to write cleaner and easy-to-maintain code.
Here are some of the key characteristics of extension methods:
Lambda Expressions
Anonymous methods is a new feature introduced with C# 2.0 that enables you to declare your method code inline instead of with a delegate function. Let us take a look at a simple anonymous method:
public Forms()
{
check = new CheckBox(...);
text = new TextBox(...);
checkBox.CheckedChanged += delegate
{
text.Text = "...";
};
}
As you can see in the above code, you don't have to explicitly declare a new method to link it with an event. C# 3.0 introduces an even simpler syntax, lambda expressions, which you write as a parameter list followed by the "=>" token, followed by an expression or a statement block.
Lambda expressions are simply functions and they are declared in the context of expressions than as a member of a class. It is an inline expression or a statement block which can be used to pass arguments to a method or assign value to delegate. All lambda expressions use the lambda operator => and the left side of the operator denotes the results and the right side contains the expression to be evaluated. For instance, consider the following lambda expression:
age => age + 1
The above function takes one argument named age, and returns age + 1 as the result. As you can see, Lambda expressions follow the below syntax:
(parameter-list) => expression;
where expression can be any C# expression or a block of code. Just like anonymous methods you can use a lambda expression in place of a delegate. Here are some sample lambda expressions and their corresponding delegates.
//Explicitly typed parameter
(Person obj) => MessageBox.Show(obj.FirstName.ToUpper());
//Implicitly typed parameter
(obj) => obj.FirstName == "Thiru";
//Explicitly typed parameter
(int a, int b) => a + b
//Implicitly typed parameter
(x, y) => { return x + y; }
As you see from the preceding lines of code, lambda expressions can be written in such a way that it can infer the parameter type from the signature of the delegate it is assigned to.
To understand type inference, let us look at couple of lines of code.
var count = 1;
var output = "This is a string";
var employees = new EmployeesCollection();
In the above lines of code, the compiler sees the var keyword, looks at the assignment to count, and determines that it should be an Int32, then assigns 1 to it. When it sees that you assign a string to the output variable, it determines that output should be of type System.String. Same goes for employees collection object. As you would have guessed by now, var is a new keyword introduced in C# 3.0 that has a special meaning. var is used to signal the compiler that you are using the new Local Variable Type Inference feature in C# 3.0.
As an example, let us modify our string query example to use the var keyword.
string[] names = {"John", "Peter", "Joe", "Patrick", "Donald", "Eric"};
var namesWithFiveCharacters =
from name in names
where name.Length < 5
select name'
var lstResults = new List();
foreach(var name in namesWithFiveCharacters)
lstResults.Add(name);
With Tethering, your phone can share its mobile data connection with a single computer using a USB cable. With Wi-Fi Sharing, your phone can share its mobile data connection with up to five devices wirelessly.
** Device tethering is only available on Devices running 2.2 or higher OS**
To tether your device with a computer or other device and use it as a modem, follow these steps:
Your device starts sharing its mobile network data connection with your computer or other device via the USB connection.
To turn on Mobile AP, follow these steps:
When you turn on Mobile AP, your device starts broadcasting its Wi-Fi network name (Service Set Identifier) so you can connect to it with up to five computers or other devices. The SSID is a unique key that identifies a wireless Local Area Network (LAN). The purpose of the SSID is to stop other wireless equipment from accessing your LAN — whether accidentally or intentionally. To communicate, wireless devices must be configured with the same SSID. To configure devices with your device’s SSID, follow these steps:
Took me a while to find this redirect issue. Glad I can across this blog from Jon B. Gallant.
Quote from Jon B. Gallant http://blogs.msdn.com/b/jongallant/archive/2006/06/20/640484.aspx
The second parameter overload of Response.Redirect is nice because it doesn't call Response.End, which is responsible for throwing the ThreadAbortException. BUT...
The drawback to using this is that the page will continue to process on the server and be sent to the client. If you are doing a redirect in Page_Init (or like) and call Response.Redirect(url, false) the page will only redirect once the current page is done executing. This means that any server side processing you are performing on that page WILL get executed. In most cases, I will take the exception perf hit over the rendering perf hit, esp since the page won't be rendered anyway and that page could potentially have a ton of data. Using Fiddler I was also able monitor my http traffic and see that when using this redirect method the page is actually being sent to the client as well.
I don't usually do redirects in try/catch blocks, but if you do the ThreadAbortException will be handled by your catch and potentially cause a transaction Abort (depending on what you are doing of course). If you do put the redirect in the try block, then you'll need to explicitly catch the ThreadAbortException or create a wrapper method that does that for you.
Something like this would work.
///
[ServiceContract]
public interface ICalendarService
{
[OperationContract(Name = "GetScheduledEventsByDate")]
ScheduledEvent[] GetScheduledEvents(DateTime date);
[OperationContract(Name = "GetScheduledEventsByDateRange")]
ScheduledEvent[] GetScheduledEvents(DateTime start, DateTime end);
}
For more info: here
CREATE PROCEDURE GetContacts ( @ModuleID int, @maxrows int = 0 ) AS SET ROWCOUNT @maxrows SELECT ItemID, CreatedDate, CreatedByUser, Name, Role, Email, Contact1, Contact2 FROM Contacts WHERE ModuleID = @ModuleIDFor more info: http://authors.aspalliance.com/stevesmith/articles/sprowcount.asp