Note The code for the RemoveMacros method was adapted from a Visual Studio 2005 Code Snippet for in Word

Implementation 2d Data Matrix barcode in Word Note The code for the RemoveMacros method was adapted from a Visual Studio 2005 Code Snippet for

// Assign 5 to ss1.X and cs1.X // Assign 10 to ss1.Y and cs1.Y // Assign class instance // Assign struct instance

The language implicitly supplies a parameterless constructor for every struct. This constructor sets each of the struct s members to the default value for that type. Value members are set to their default values. Reference members are set to null. The predefined parameterless constructor exists for every struct and you cannot delete or redefine it. You can, however, create additional constructors, as long as they have parameters. Notice that this is different from classes. For classes, the compiler will supply an implicit parameterless constructor only if no other constructors are declared. To call a constructor, including the implicit parameterless constructor, use the new operator. Notice that the new operator is used even though the memory is not allocated from the heap. For example, the following code declares a simple struct with a constructor that takes two int parameters. Main creates two instances of the struct one using the implicit parameterless constructor and the second with the declared two-parameter constructor. struct Simple { public int X; public int Y; public Simple(int a, int b) { X = a; Y = b; } } class Program { static void Main() { Call implicit constructor Simple s1 = new Simple(); Simple s2 = new Simple(5, 10); Call constructor Console.WriteLine("{0},{1}", s1.X, s1.Y); Console.WriteLine("{0},{1}", s2.X, s2.Y); } } // Constructor with parameters

This code produces the following output:

The INDIRECT function requires one argument =INDIRECT(ref_text) and returns the range specified by the reference text argument. For example, if Cell E1 contains the text A3, the following formula would return the value from Cell A3: =INDIRECT(E1)

In this chapter, you ve seen two types of function members that have get and set accessors: properties and indexers. By default, both a member s accessors have the same access level as the member itself. That is, if a property has an access level of public, then both its accessors have that same access level. The same is true of indexers. With C# 2.0, the accessors of a member can now, under certain conditions, have different access levels. For example, in the following code, property Name has an access level of public, but the set accessor has an access level of protected. class MyClass { private string _Name = "John Doe"; public string Name { get { return _Name; } protected set { _Name = value; } } } There are several restrictions on the access modifiers of accessors. The most important ones are the following: An accessor can have an access modifier only if the member (property or indexer) has both a get accessor and a set accessor. Although both accessors must be present, only one of them can have an access modifier. The access modifier of the accessor must be strictly more restrictive than the access level of the member. Figure 6-19 shows the hierarchy of access levels. The access level of an accessor must be strictly lower in the chart than the access level of the member. For example, if a property has an access level of public, you can give any of the four lower access levels on the chart to one of the accessors. But if the property has an access level of protected, the only access modifier you can use on one of the accessors is private.

The key to understanding LINQ is to understand the role of expression trees in the implementation of LINQ. Expression trees are representations of source code as data. Consider the following code passed to the Where() method in LINQ: var result = someCollection.Where( x => x.SomeVal == 42); The parameter provided to the Where() method is a lambda function a more compact syntax for an anonymous method. However, when Where() is invoked, the lambda function is converted into a data structure in the form of an expression tree that looks like Figure 14-3.

The MethodCaller class throws a custom Csla.Server.CallMethodException in the case that an exception occurs while calling a method on the business object. The purpose behind throwing this exception is to supply the name of the business method that generated the exception, and to provide the original exception details as an InnerException. More importantly, it preserves the stack trace from the original exception. The original stack trace shows the details about where the exception occurred, and is very useful for debugging. Without a bit of extra work, this information is lost as the method call comes back through reflection. Remember that MethodCaller.CallMethod() uses reflection to invoke the business method. When an exception occurs in the business method, a reflection exception is thrown with the original business exception nested inside. CallMethod() strips off the reflection exception and provides the original business exception as a parameter during the creation of the CallMethodException object. In the constructor of CallMethodException, the stack trace details from that original exception are stored for later use: Public Sub New(ByVal message As String, ByVal ex As Exception) MyBase.New(message, ex) mInnerStackTrace = ex.StackTrace End Sub Then in the StackTrace property of CallMethodException, the stack trace for the CallMethodException itself is combined with the stack trace from the original exception:

Figure 7-2. InfoPath forms rendered as HTML can, of course, also be viewed in a browser. Here is the same form as in Figure 7-1, displayed in a browser.

Figure 33-26. Enabling and disabling the WPF command I am using a CheckBox to demonstrate this feature, but you can enable and disable commands based on the internal state of your program. Imagine your program is in the middle of a save operation and isn t able to perform a New command. Rather than have to keep track of all the controls that relate to the New operation, you just disable the command, and WPF takes care of the rest. When you finish the save, you enable the command again, and everything returns to normal. Being able to selectively enable and disable commands is a very handy feature that I find myself using more and more.

The typeof operator returns the System.Type object of any type given as its parameter. From this object, you can learn the characteristics of the type. (There is only one System.Type object for any given type.) You cannot overload the typeof operator. Table 8-17 lists the operator s characteristics. The typeof operator is unary. Table 8-17. The typeof Operator