Creating Web Applications |
689 |
6.Does Listing 20.1 use HTML controls, HTML server controls, or Web server controls?
7.What is the difference between a standard HTML control and an HTML server control?
8.What is the server equivalent of the standard HTML table tag?
9.How can you tell a server-side HTML control from a standard HTML control?
Exercises
1.Modify Listing 20.1. Add an ASP text box control. When the button is clicked, copy the text that the user entered into the text box to the label.
2.Modify Listing 20.2 to call a method when a successful name and password are entered. This method should display the entered name to the HTML form.
3.On Your Own: Create a Web page that uses HTML server controls. Rewrite the application to use ASP server controls.
4.On Your Own: Review the online documentation that might have come with your compiler. Look up HTML server controls and Web server controls. Review the different properties, methods, and events that are associated with these controls.
20
WEEK 3
DAY 21
A Day for Reflection and Attributes
At this point, you have worked through 14 days of learning fundamentals of the C# programming language and another 6 days of using the C# language with the .NET Framework. You have learned about data types, classes, objectoriented programming, and much more. You have learned all the basics of C# programming. You have the ability to create C# programs, including programs that use the Base Class Library (BCL) classes and more. These can be Windows-based, Web-based, or those within the console. In today’s lesson, you touch on a couple of advanced-level topics within C# that you might come across. Today you…
•Discover the concept of reflection.
•Use reflection to determine the contents of a program.
•Learn how to use predefined attributes.
•Explore the creation of custom attributes.
•See how to associate custom attributes with your code.
A Day for Reflection and Attributes |
693 |
The MemberInfo type is a part of the Reflection namespace. You need to include
System.Reflection to use the shortened version of the name.
LISTING 21.1 MyMemberInfo.cs—Using Reflection
1:using System;
2:using System.Reflection;
4:class MyMemberInfo
5:{
6:public static int Main()
7:{
8://Get the Type and MemberInfo.
9:string testclass = “System.Reflection.PropertyInfo”;
11:Console.WriteLine (“\nFollowing is the member info for class: {0}”,
12: |
testclass); |
13: |
|
14: |
Type MyType = Type.GetType(testclass); |
15: |
|
16: |
MemberInfo[] MyMemberInfoArray = MyType.GetMembers(); |
17: |
|
18: |
//Get the MemberType method and display the elements |
19: |
|
20:Console.WriteLine(“\nThere are {0} members in {1}”,
21: |
MyMemberInfoArray.GetLength(0), |
22: |
MyType.FullName); |
23: |
|
24:for ( int counter = 0;
25:counter < MyMemberInfoArray.GetLength(0);
26:counter++ )
27:{
28:Console.WriteLine( “{0}. {1} Member type - {2}”,
29: |
counter, |
30: |
MyMemberInfoArray[counter].Name, |
31: |
MyMemberInfoArray[counter].MemberType.ToString()); |
32:}
33:return 0;
34:}
35:}
Following is the member info for class: System.Reflection.PropertyInfo
OUTPUT
There are 36 members in System.Reflection.PropertyInfo |
21 |
|
|
||
0. |
get_CanWrite Member type - Method |
|
1. |
get_CanRead Member type - Method |
|
2. |
get_Attributes Member type - Method |
|
3. |
GetIndexParameters Member type - Method |
|
4. |
GetSetMethod Member type - Method |
|
A Day for Reflection and Attributes |
695 |
A great enhancement to this listing would be to capture a command-line parameter that indicates which class to reflect upon. I’ll leave that to you to add. By using a commandline value, you wouldn’t need to recompile each time you wanted to change the class being reflected on. This also illustrates a key point—reflection can happen at runtime.
In Line 14, the name of a class is passed to the Type.GetType method. The returned type is assigned to the variable MyType. The MyType object is then used to get the members of the type it contains. These are assigned to a MemberInfo array named MyMemberInfoArray in Line 16. Lines 24–32 then loop through this array and print the Name and the MemberType values for each element. As you can see, the Name element contains the name of the member. The MemberType when displayed as a string tells you the type of the individual member.
Getting basic information is relatively easy. If you want to get more specific information, a little more work is involved. Before getting to that, look at a second listing illustrating the MemberInfo objects. Listing 21.2 presents another look at the process of reflection.
LISTING 21.2 Reflect.cs—A Second Look at Reflection
1:// Reflect.cs
2://------------------------------
3:using System;
4:using System.Reflection;
5:
6:namespace Reflect
7:{
8:
9:class MyMemberInfo
10:{
11:int classMyValue;
13:public void THIS_IS_A_METHOD()
14:{
15://
16:}
17: |
|
|
18: |
public int MyValue |
// property |
19:{
20:set { classMyValue = value; }
21:}
22:
23: |
public static int Main() |
21 |
|
||
24: |
{ |
|
25: |
//The following is the class being checked |
|
26: |
string testclass = “Reflect.MyMemberInfo”; |
|
27: |
|
|
A Day for Reflection and Attributes |
699 |
In general, an attribute is associated with the code element that follows it. Some of the code elements that an attribute can be associated with are listed in Table 21.2.
TABLE 21.2 Elements Associated with Attributes
Element |
Explicit Specifier |
Assembly |
assembly |
Event method |
event |
Field |
field |
Method |
method |
Program module |
module |
Parameter |
param |
Property |
property |
Return value |
return |
Class or structure |
type |
|
|
From Table 21.2, you can see that an attribute can be associated with a number of different elements. Consider the following example:
[MyAttribute] class MyClass {}
The MyAttribute attribute appears before a class. The attribute would therefore be associated with the MyClass class.
Now consider a second example:
[MyAttribute]
public int MyMethod() {}
This looks very similar to the WebMethod attribute. What is this attribute associated with? Table 21.2 lists a number of elements. Is MyAttribute associated to the method? MyAttribute could be associated to either the method or the return type.
C# gives you a way to make explicit where you want the attribute associated. This is done using one of the explicit terms in Table 21.2. The ambiguity can be resolved by including the explicit term at the beginning of the attribute, with a colon for separation. To associate the MyAttribute attribute with the return value, you use the following:
[return:MyAttribute] |
21 |
public int MyMethod() {} |
|
