Developer .NET UPDATE —brought to you by the Windows & .NET Magazine Network
http://www.winnetmag.com
THIS ISSUE SPONSORED BY
Windows & .NET Magazine LIVE!
http://www.winnetmagLIVE.com
SQL Server Magazine LIVE!
http://www.sqlmagLIVE.com
(below DEVELOPER .NET PERSPECTIVES)
SPONSOR: WINDOWS & .NET MAGAZINE LIVE!
REAL-WORLD TIPS AND SOLUTIONS HERE FOR YOU
This conference is chock full of "been there, done that" information from people who use Microsoft products in the real world. Increase your productivity with shortcuts, tips, and tricks you'll learn only at Windows & .NET Magazine LIVE! (Oct 30. Nov. 2).
This must-attend event will help you keep your skills sharp. Loaded with practical information you can use right away. Real-world technical tips and insights you don't want to miss.
Register now and you'll receive FREE access to sessions of concurrently run XML Web Services Connections. Stay the whole week and catch SQL Server Magazine LIVE! and Microsoft ASP.NET Connections at deeply discounted prices. Register today before these events sell out.https://secure.win2000mag.com/events/windows_register.asp
August 20, 2002—In this issue:
1. DEVELOPER .NET PERSPECTIVES
- Speaking as an Engineer and an Author
2. ANNOUNCEMENTS
- Planning on Getting Certified? Make Sure to Pick Up Our New eBook!
- Take Our Survey and You Could Win a Free T-Shirt!
3. RESOURCE
- Featured Thread: Visual Studio .NET Mystery
4. NEW AND IMPROVED
- Understand How Your Applications Interact with Oracle
5. CONTACT US
- See this section for a list of ways to contact us.
1. DEVELOPER .NET PERSPECTIVES
(contributed by Bill Sheldon, [email protected])
I work as an engineer for InterKnowlogy and as an author for Penton Technology Media. These two roles have a few tasks in common (e.g., writing code), yet how I accomplish the common tasks differs for each role.
Just as I have two roles, objects in an application can have two (or more) roles. To fill the dual roles, the object might need to inherit methods and properties from two classes. This concept is known as multiple inheritance. Languages that support multiple inheritance include C++ and SmallTalk.
Problems can arise when an object inherits from two classes and those classes have a method or property with the same name but not the same functionality. When the runtime environment encounters such a method, it determines which one of the two methods to use based on the declaration order of the inherited classes within the source file. In other words, the runtime environment checks an inheritance hierarchy and defaults to whichever class is highest in the hierarchy.
Selecting a method based on an inheritance hierarchy isn't the most type-safe way to handle ambiguous situations. At compile time, type safety ensures that the code specifies the correct underlying data and method format so that you can optimize the code and easily detect and correct any errors. The problem with multiple inheritance is that while the compiler might select a method, its selection isn't necessarily apparent or correct. For this reason, the Microsoft .NET Framework doesn't support multiple inheritance, which means every .NET class has only one parent. Not supporting multiple inheritance ensures type safety because only one set of methods and properties exists for each class. However, the lack of support for multiple inheritance makes handling an object with multiple roles quite challenging. To resolve this problem, the .NET Framework supports interface inheritance, which provides the core features of multiple inheritance without leaving any runtime ambiguity regarding which method to execute.
To understand how interface inheritance works, suppose that when I was first hired as an engineer, I created an application that included an object that represented my role as an engineer. At the time, I didn't know I would later fill the role of an author, so I created an engineer class that inherits from an employee class, which in turn, inherits from a person class.
This class structure works quite well for my initial role and lets the application handle different types of employee roles should I decide to change jobs within the company. However, I now need to add my new role as an author to this class definition. Having the author class inherit from an existing class in the class structure might be tempting, but doing so would incorrectly associate authors with a specific role within the hierarchy. Not all engineers are authors, and not all authors are engineers. Thus, I need to implement a second role that doesn't inherit from the same structure that the existing object uses. In addition, I don't want to have to change and retest the implementation of the engineer class to account for this additional role. In this type of situation, interface inheritance comes in handy. (For an overview about when you should use interfaces, go to http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vbcn7/html/vaconwhentouseinterfaces.asp.)
The Interface keyword in both Visual Basic .NET and Visual C# .NET lets you define an interface. Fortunately, an interface's definition is similar in both languages. You specify the protection level (typically public), name of the interface, and any methods or properties that are required to define an object of that type. For example, if you want to declare and define an interface called IAuthorProp in Visual Basic .NET, you use the code
Public Interface IAuthorProp Property MyTask() as String String AssignArticle(string MyTask); End Interface
The IAuthorProp interface defines one property called MyTask, which is a String type. The interface also defines a method called AssignArticle that you can use to assign a task to an author. However, the interface doesn't define what happens when you assign an article to an author—that definition depends on the class that implements the interface.
Let's define a similar interface in Visual C# .NET. To declare and define an interface called IAuthorMeth that has one mandatory method called AssignTask, you use the code
public interface IAuthorMeth
\{
String AssignArticle(string MyTask);
\}
In both the Visual Basic .NET and Visual C# .NET sample code, notice that the declarations don't include implementation code. Unlike implementation and source inheritance, interface inheritance doesn't provide for implementation. In interface inheritance, the class handles the implementation. Thus, each class that implements the interface can provide its own unique definition. The implementation won't be reused unless another class inherits it.
To prompt an interface's implementation in Visual Basic .NET, you use the Implements keyword. You must use the Implements keyword not only in the class definition but also in the definition of each method and property. For example, suppose you want to implement an interface called IAuthorCS that has the AssignArticle method and the MyTask property. In the class definition, you use the code
Public Class Engineer Inherits Employee Implements IAuthorCS
In the definition of the AssignArticle method, you use the code
Public Sub AssignArticle( ByVal MyTask as String) _ Implements IAuthorCS.AssignArticle ' code End Sub
In the definition of the MyTask property, you use the code
Public Property MyTask() As String Implements IAuthorsCS.MyTask
Get
Return MyTask
End Get
Set(ByVal Value As String)
MyTask = Value
End Set
End Property
For more information about defining interfaces in Visual Basic .NET, go to http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vbcn7/html/vaconinterfaces.asp.
Like Visual Basic .NET, Visual C# .NET requires you to include implementation code in the class definition and in each property's or method's definition. However, you don't use the Implements keyword in Visual C# .NET. Instead, in the class definition, you place the interface to be implemented after the base class. Thus, in Visual C# .NET, the class definition for the IAuthorCS interface would be
public class Engineer : Employee, IAuthorCS
Then, to implement the AssignArticle method and MyTask property, you use the code
public void AssignArticle(string MyTask)
\{
// code
\}
public string MyTask
\{
get
\{
return MyTask;
\}
set
\{
MyTask = value;
\}
\}
The AssignArticle method looks and behaves like any other method in the class. The compiler automatically recognizes that the AssignArticle method is part of the interface and not the class. For more information about defining interfaces in Visual C# .NET, see http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cscon/html/vcurfccodewizards.asp.
Whether you're working with Visual Basic .NET or Visual C# .NET, interface implementation lets you extend the functionality that's part of the class definition without placing other code that relies on that definition at risk. Thus, after you implement the interface, you can cast the class as a type, with code such as
Dim Eng as New Engineer Dim Aut as IAuthorCS = Eng
Even better than casting is creating code in the application that accepts a parameter defined as IAuthorCS. Thus, whether the object with which you're working represents an engineer or a project manager, you can pass this object to the code as long as the object being passed includes the implementation of the IAuthorCS interface. Therein lies the power of interfaces—they let you extend the class structure without requiring you to change the inheritance structure.
One disadvantage in how the .NET Framework implements interfaces involves the overlap of the same methods. If two interfaces define the same method or property, the class implementing them needs to create a single implementation. In Visual C# .NET, the creation of a single implementation occurs automatically because, by definition, you can have two different method implementations with the same name and parameter list. In Visual Basic .NET, you can't have two different method implementations with the same name and parameter list, so you need to extend the Implements line. For example, if both the IAuthorCS and IAuthorVB interfaces defined the AssignArticle Method, the class, method, and property definitions would be
Public Class Engineer Inherits Employee
Implements IAuthorCS
Implements IAuthorVB
Public Sub AssignArticle( ByVal MyTask as String) _
Implements IAuthorCS.AssignArticle, IAuthorVB.AssignArticle
' code
End Sub
Public Property MyTask() As String _
Implements IAuthorsCS.MyTask, IAuthorsVB.MyTask
Get
Return MyTask
End Get
Set (ByVal Value As String)
MyTask = Value
End Set
End Property
End Class
Thus, when you're creating interface definitions, you'll want to assign unique names to those methods and properties that require specific implementations. This point leads us to another disadvantage of the .NET Framework: It doesn't provide a clean way to support different actions based on the use of, for example, the IAuthorMeth.AssignArticle method vs. the IAuthorProp.AssignArticle method. Instead, you must make sure that these methods have different implementations by either assigning the methods different names or by adding parameters to one method so that the methods have different parameter lists.
Although the .NET environment doesn't support multiple inheritance, it uses interface inheritance to provide the same power. At the same time, the .NET Framework prevents ambiguous inheritance, thereby ensuring type safety during compilation.
SPONSOR: SQL SERVER MAGAZINE LIVE
NEW IDEAS, TIPS, AND ADVICE YOU NEED TO KNOW
Over 60 SQL-specific sessions in this real-world, best-practices-packed conference. Ready for your consumption are the latest SQL tools, tips, and real-life examples you can't live without.
Register now and access concurrently run Microsoft ASP.NET Connections and Visual Studio .NET Connections for FREE—over 160 sessions to choose from.
https://secure.win2000mag.com/events/sql_register.asp
2. ANNOUNCEMENTS
(brought to you by Windows & .NET Magazine and its partners)
"The Insider's Guide to IT Certification" eBook is hot off the press and contains everything you need to know to help you save time and money while preparing for certification exams from Microsoft, Cisco Systems, and CompTIA and have a successful career in IT. Get your copy of the Insider's Guide today!
http://winnet.bookaisle.com/ebookcover.asp?ebookid=13475
We need to hear your thoughts on the future of technology! Take our reader survey, and you'll be entered to win a T-shirt, compliments of Windows & .NET Magazine. All responses are completely confidential, so visit
http://www.up2research.com/windotnet
3. RESOURCE
Kerry is able to use Visual Studio .NET on one computer but not another in the same lab, despite logging on to each computer as the same user with the same permissions. If you can shed some light on this mystery, go to
http://www.winnetmag.com/forums/messageview.cfm?catid=36&threadid=44634
4. NEW AND IMPROVED
(contributed by Carolyn Mader, [email protected])
Compuware announced DevPartnerDB for Oracle, software that can debug Oracle stored procedures from within the Visual Studio .NET development environment. DevPartnerDB for Oracle is a development tool for performing proactive analysis and debugging of Procedural Language/SQL (PL/SQL). The software helps developers understand how their applications interact with Oracle. DevPartnerDB for Oracle runs on Windows XP and Windows 2000 systems and supports Oracle 8.0 and higher. For pricing, contact Compuware at 248-737-7300.
http://www.compuware.com
5. CONTACT US
Here's how to reach us with your comments and questions:
- ABOUT THE COMMENTARY — [email protected]
- ABOUT THE NEWSLETTER IN GENERAL — [email protected]
(please mention the newsletter name in the subject line)
- TECHNICAL QUESTIONS — http://www.winnetmag.net/forums
- PRODUCT NEWS — [email protected]
- QUESTIONS ABOUT YOUR .NET UPDATE SUBSCRIPTION?
Customer Support — [email protected]
- WANT TO SPONSOR DEVELOPER .NET UPDATE?
[email protected]
This email newsletter is brought to you by Windows & .NET Magazine, the leading publication for Windows professionals who want to learn more and perform better. Subscribe today.
http://www.winnetmag.com/sub.cfm?code=wswi201x1z
Receive the latest information about the Windows and .NET topics of your choice. Subscribe to our other FREE email newsletters.
http://www.winnetmag.net/email
