DOCSLIB.ORG

Fundamental Programming Concepts

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Fundamental Programming Concepts APPENDIX A Fundamental Programming Concepts The following information is for readers who are new to programming and need a primer on some fundamental programming concepts. If you have programmed in another language, chances are the concepts presented in this appendix are not new to you. You should, however, review the material briefly to become familiar with the C# syntax. Working with Variables and Data Types Variables in programming languages store values that can change while the program executes. For example, if you wanted to count the number of times a user tries to log in to an application, you could use a variable to track the number of attempts. A variable is a memory location where a value is stored. Using the variable, your program can read or alter the value stored in memory. Before you use a variable in your program, however, you must declare it. When you declare a variable, the compiler also needs to know what kind of data will be stored at the memory location. For example, will it be numbers or letters? If the variable will store numbers, how large can a number be? Will the variable store decimals or only whole numbers? You answer these questions by assigning a data type to the variable. A login counter, for example, only needs to hold positive whole numbers. The following code demonstrates how you declare a variable named counter in C# with an integer data type: int counter; Specifying the data type is referred to as strong typing. Strong typing results in more efficient memory management, faster execution, and compiler type checking, all of which reduces runtime errors. Runtime errors are errors that can occur while a program is running and are not caught by the compiler when you build the application. For example, incorrect rounding can occur as a result of using the wrong data types in a calculation. Once you declare the variable, you need to assign it an initial value, either in a separate statement or within the declaration statement itself. For instance, the following code: int counter = 1; is equivalent to this: int counter; counter = 1; Understanding Elementary Data Types C# supports elementary data types such as numeric, character, and date types. 325 APPENDIX A N FUNDAMENTAL PROGRAMMING CONCEPTS Integral Data Types Integral data types represent whole numbers only. Table A-1 summarizes the integral data types used in C#. Table A-1. Integral Data Types Data Type Storage Size Value Range Byte 8-bit 0 through 255 Short 16-bit –32,768 through 32,767 Integer 32-bit –2,147,483,648 through 2,147,483,647 Long 64-bit –9,223,372,036,854,775,808 through 9,223,372,036,854,775,807 Obviously, memory size is important when choosing a data type for a variable. A less obvious consideration is how easily the compiler works with the data type. The compiler performs arithmetic operations with integers more efficiently than the other types. Often, it’s better to use integers as counter variables even though a byte or short type could easily manage the maximum value reached. Non-Integral Data Types If a variable will store numbers that include decimal parts, then you must use a non-integral data type. C# supports the non-integral data types listed in Table A-2. Table A-2. Non-Integral Data Types Data Type Storage Size Value Range Single 32-bit –3.4028235E+38 through –1.401298E–45 for negative values; 1.401298E–45 through 3.4028235E+38 for positive values Double 64-bit 1.79769313486231570E+308 through –4.94065645841246544E–324 for negative values; 4.94065645841246544E–324 through 1.79769313486231570E+308 for positive values Decimal 128-bit 0 through +/–79,228,162,514,264,337,593,543,950,335 with no decimal point; 0 through +/–7.9228162514264337593543950335 with 28 places to the right of the decimal The decimal data type holds a larger number of significant digits than either the single or the double data types and it is not subject to rounding errors. Decimal data types are usually reserved for financial or scientific calculations that require a higher degree of precision. Character Data Types Character data types are for variables that hold characters used in human languages. For example, a character data type holds letters such as “a” or numbers used for display and printing such as “2 apples.” The character data types in C# are based on Unicode, which defines a character set that can represent the characters found in every language from English to Arabic and Mandarin Chinese. C# supports two character data types: char and string. The char data type holds single (16-bit) Unicode character values such as a or B. The string data type holds a sequence of Unicode characters. It can range from zero up to about two billion characters. 326 APPENDIX A N FUNDAMENTAL PROGRAMMING CONCEPTS Boolean Data Type The Boolean data type holds a 16-bit value that is interpreted as true or false. It’s used for variables that can be one of only two values, such as yes or no, or on or off. Date Data Type Dates are held as 64-bit integers where each increment represents a period of elapsed time from the start of the Gregorian calendar (1/1/0001 at 12:00 a.m.). Object Data Type An object data type is a 32-bit address that points to the memory location of another data type. It is commonly used to declare variables when the actual data type they refer to can’t be determined until runtime. Although the object data type can be a catch-all to refer to the other data types, it is the most inefficient data type when it comes to performance and should be avoided unless absolutely necessary. Nullable Types By default, value types such as the Boolean, integer, and double data types can’t be assigned a null value. This can become problematic when retrieving data from data structures such as a database that does allow nulls. When declaring a value type variable that may be assigned a null, you make it a nullable type by placing a question mark symbol (?) after the type name, like so: double salary = null; // Not allowed. double? salary = null; // allowed. Introducing Composite Data Types Combining elementary data types creates composite data types. Structures, arrays, and classes are examples of composite data types. Structures A structure data type is useful when you want to organize and work with information that does not need the overhead of class methods and constructors. It’s well suited for representing lightweight objects such as the coordinates of a point or rectangle. A single variable of type structure can store such information. You declare a structure with the struct keyword. For example, the following code creates a structure named Point to store the coordinates of a point in a two-dimensional surface: public struct Point { public int _x, _y; 327 APPENDIX A N FUNDAMENTAL PROGRAMMING CONCEPTS public Point(int x, int y) { _x = x; _y = y; } } Once you define the structure, you can declare a variable of the structure type and create a new instance of the type, like so: Point p1 = new Point(10,20); Arrays Arrays are often used to organize and work with groups of the same data type; for example, you may need to work with a group of names, so you declare an array data type by placing square brackets ([]) immediately following the variable name, like so: string[] name; The new operator is used to create the array and initialize its elements to their default values. Because the elements of the array are referenced by a zero-based index, the following array holds five elements: string[] name = new string[4]; To initialize the elements of an array when the array is declared, you use curly brackets ({}) to list the values. Since the size of the array can be inferred, you do not have to state it. string[] name = {"Bob","Bill","Jane","Judy"}; C# supports multidimensional arrays. When you declare the array, you separate the size of the dimensions by commas. The following declaration creates a two-dimensional array of integers with five rows and four columns: string[,] name = new string[4,3]; To initialize the elements of a two-dimensional array when the array is declared, you use curly brackets inside curly brackets to list the array elements. int[,] intArray = {{1,2}, {3,4}, {5,6}, {7,8}}; You access elements of the array using its name followed by the index of the element in brackets. Index numbering starts at 0 for the first element. For example, name[2] references the third element of the names array declared previously and has a value of Jane. 328 APPENDIX A N FUNDAMENTAL PROGRAMMING CONCEPTS Classes Classes are used extensively in object-oriented programming languages. Most of this book is devoted to their creation and use. At this point, it suffices to say that classes define a complex data type for an object. They contain information about how an object should behave, including its name, methods, properties, and events. The .NET Framework contains many predefined classes with which you can work. You can also create your own class type definitions. A variable defined as a class type contains an address pointer to the memory location of the object. The following code declares an object instance of the StringBuilder class defined in the .NET Framework: StringBuilder sb = new StringBuilder(); Looking at Literals, Constants, and Enumerations Although the values of variables change during program execution, literals and constants contain items of data that do not change.
Load more

Recommended publications
  • Datatypes (Pdf Format)
    Basic Scripting, Syntax, and Data Types in Python Mteor 227 – Fall 2020 Basic Shell Scripting/Programming with Python • Shell: a user interface for access to an operating system’s services. – The outer layer between the user and the operating system. • The first line in your program needs to be: #!/usr/bin/python • This line tells the computer what python interpreter to use. Comments • Comments in Python are indicated with a pound sign, #. • Any text following a # and the end of the line is ignored by the interpreter. • For multiple-line comments, a # must be used at the beginning of each line. Continuation Line • The \ character at the end of a line of Python code signifies that the next line is a continuation of the current line. Variable Names and Assignments • Valid characters for variable, function, module, and object names are any letter or number. The underscore character can also be used. • Numbers cannot be used as the first character. • The underscore should not be used as either the first or last character, unless you know what you are doing. – There are special rules concerning leading and trailing underscore characters. Variable Names and Assignments • Python is case sensitive! Capitalization matters. – The variable f is not the same as the variable F. • Python supports parallel assignment >>> a, b = 5, 'hi' >>> a 5 >>> b 'hi' Data Types • Examples of data types are integers, floating-point numbers, complex numbers, strings, etc. • Python uses dynamic typing, which means that the variable type is determined by its input. – The same variable name can be used as an integer at one point, and then if a string is assigned to it, it then becomes a string or character variable.
    [Show full text]
  • CWM) Specification
    Common Warehouse Metamodel (CWM) Specification Volume 1 Version 1.0 October 2001 Copyright © 1999, Dimension EDI Copyright © 1999, Genesis Development Corporation Copyright © 1999, Hyperion Solutions Corporation Copyright © 1999, International Business Machines Corporation Copyright © 1999, NCR Corporation Copyright © 2000, Object Management Group Copyright © 1999, Oracle Corporation Copyright © 1999, UBS AG Copyright © 1999, Unisys Corporation The companies listed above have granted to the Object Management Group, Inc. (OMG) a nonexclusive, royalty-free, paid up, worldwide license to copy and distribute this document and to modify this document and distribute copies of the mod- ified version. Each of the copyright holders listed above has agreed that no person shall be deemed to have infringed the copyright in the included material of any such copyright holder by reason of having used the specification set forth herein or having conformed any computer software to the specification. PATENT The attention of adopters is directed to the possibility that compliance with or adoption of OMG specifications may require use of an invention covered by patent rights. OMG shall not be responsible for identifying patents for which a license may be required by any OMG specification, or for conducting legal inquiries into the legal validity or scope of those patents that are brought to its attention. OMG specifications are prospective and advisory only. Prospective users are responsible for protecting themselves against liability for infringement of patents. NOTICE The information contained in this document is subject to change without notice. The material in this document details an Object Management Group specification in accordance with the license and notices set forth on this page.
    [Show full text]
  • Customizing and Extending Powerdesigner SAP Powerdesigner Documentation Collection Content
    User Guide PUBLIC SAP PowerDesigner Document Version: 16.6.2 – 2017-01-05 Customizing and Extending PowerDesigner SAP PowerDesigner Documentation Collection Content 1 PowerDesigner Resource Files.................................................... 9 1.1 Opening Resource Files in the Editor.................................................10 1.2 Navigating and Searching in Resource Files............................................ 11 1.3 Editing Resource Files........................................................... 13 1.4 Saving Changes................................................................13 1.5 Sharing and Embedding Resource Files...............................................13 1.6 Creating and Copying Resource Files.................................................14 1.7 Specifying Directories to Search for Resource Files.......................................15 1.8 Comparing Resource Files........................................................ 15 1.9 Merging Resource Files.......................................................... 16 2 Extension Files................................................................18 2.1 Creating an Extension File.........................................................19 2.2 Attaching Extensions to a Model....................................................20 2.3 Exporting an Embedded Extension File for Sharing.......................................21 2.4 Extension File Properties......................................................... 21 2.5 Example: Adding a New Attribute from a Property
    [Show full text]
  • A Hybrid Static Type Inference Framework with Neural
    HiTyper: A Hybrid Static Type Inference Framework with Neural Prediction Yun Peng Zongjie Li Cuiyun Gao∗ The Chinese University of Hong Kong Harbin Institute of Technology Harbin Institute of Technology Hong Kong, China Shenzhen, China Shenzhen, China [email protected] [email protected] [email protected] Bowei Gao David Lo Michael Lyu Harbin Institute of Technology Singapore Management University The Chinese University of Hong Kong Shenzhen, China Singapore Hong Kong, China [email protected] [email protected] [email protected] ABSTRACT also supports type annotations in the Python Enhancement Pro- Type inference for dynamic programming languages is an impor- posals (PEP) [21, 22, 39, 43]. tant yet challenging task. By leveraging the natural language in- Type prediction is a popular task performed by most attempts. formation of existing human annotations, deep neural networks Traditional static type inference techniques [4, 9, 14, 17, 36] and outperform other traditional techniques and become the state-of- type inference tools such as Pytype [34], Pysonar2 [33], and Pyre the-art (SOTA) in this task. However, they are facing some new Infer [31] can predict sound results for the variables with enough challenges, such as fixed type set, type drift, type correctness, and static constraints, e.g., a = 1, but are unable to handle the vari- composite type prediction. ables with few static constraints, e.g. most function arguments. To mitigate the challenges, in this paper, we propose a hybrid On the other hand, dynamic type inference techniques [3, 37] and type inference framework named HiTyper, which integrates static type checkers simulate the workflow of functions and solve types inference into deep learning (DL) models for more accurate type according to input cases and typing rules.
    [Show full text]
  • PL/SQL Data Types
    PPLL//SSQQLL -- DDAATTAA TTYYPPEESS http://www.tutorialspoint.com/plsql/plsql_data_types.htm Copyright © tutorialspoint.com PL/SQL variables, constants and parameters must have a valid data type, which specifies a storage format, constraints, and valid range of values. This tutorial will take you through SCALAR and LOB data types available in PL/SQL and other two data types will be covered in other chapters. Category Description Scalar Single values with no internal components, such as a NUMBER, DATE, or BOOLEAN. Large Object LOB Pointers to large objects that are stored separately from other data items, such as text, graphic images, video clips, and sound waveforms. Composite Data items that have internal components that can be accessed individually. For example, collections and records. Reference Pointers to other data items. PL/SQL Scalar Data Types and Subtypes PL/SQL Scalar Data Types and Subtypes come under the following categories: Date Type Description Numeric Numeric values on which arithmetic operations are performed. Character Alphanumeric values that represent single characters or strings of characters. Boolean Logical values on which logical operations are performed. Datetime Dates and times. PL/SQL provides subtypes of data types. For example, the data type NUMBER has a subtype called INTEGER. You can use subtypes in your PL/SQL program to make the data types compatible with data types in other programs while embedding PL/SQL code in another program, such as a Java program. PL/SQL Numeric Data Types and Subtypes Following
    [Show full text]
  • ACDT: Architected Composite Data Types Trading-In Unfettered Data Access for Improved Execution
    ACDT: Architected Composite Data Types Trading-in Unfettered Data Access for Improved Execution Andres Marquez∗, Joseph Manzano∗, Shuaiwen Leon Song∗, Benoˆıt Meistery Sunil Shresthaz, Thomas St. Johnz and Guang Gaoz ∗Pacific Northwest National Laboratory fandres.marquez,joseph.manzano,[email protected] yReservoir Labs [email protected] zUniversity of Delaware fshrestha,stjohn,[email protected] Abstract— reduction approaches associated with improved data locality, obtained through optimized data and computation distribution. With Exascale performance and its challenges in mind, one ubiquitous concern among architects is energy efficiency. In the SW-stack we foresee the runtime system to have a Petascale systems projected to Exascale systems are unsustainable particular important role to contribute to the solution of the at current power consumption rates. One major contributor power challenge. It is here where the massive concurrency is to system-wide power consumption is the number of memory managed and where judicious data layouts [11] and data move- operations leading to data movement and management techniques ments are orchestrated. With that in mind, we set to investigate applied by the runtime system. To address this problem, we on how to improve efficiency of a massively multithreaded present the concept of the Architected Composite Data Types adaptive runtime system in managing and moving data, and the (ACDT) framework. The framework is made aware of data trade-offs an improved data management efficiency requires. composites, assigning them a specific layout, transformations Specifically, in the context of run-time system (RTS), we and operators. Data manipulation overhead is amortized over a explore the power efficiency potential that data compression larger number of elements and program performance and power efficiency can be significantly improved.
    [Show full text]
  • MPLAB C Compiler for PIC24 Mcus and Dspic Dscs User's Guide
    MPLAB® C Compiler for PIC24 MCUs and dsPIC® DSCs User’s Guide 2002-2011 Microchip Technology Inc. DS51284K Note the following details of the code protection feature on Microchip devices: • Microchip products meet the specification contained in their particular Microchip Data Sheet. • Microchip believes that its family of products is one of the most secure families of its kind on the market today, when used in the intended manner and under normal conditions. • There are dishonest and possibly illegal methods used to breach the code protection feature. All of these methods, to our knowledge, require using the Microchip products in a manner outside the operating specifications contained in Microchip’s Data Sheets. Most likely, the person doing so is engaged in theft of intellectual property. • Microchip is willing to work with the customer who is concerned about the integrity of their code. • Neither Microchip nor any other semiconductor manufacturer can guarantee the security of their code. Code protection does not mean that we are guaranteeing the product as “unbreakable.” Code protection is constantly evolving. We at Microchip are committed to continuously improving the code protection features of our products. Attempts to break Microchip’s code protection feature may be a violation of the Digital Millennium Copyright Act. If such acts allow unauthorized access to your software or other copyrighted work, you may have a right to sue for relief under that Act. Information contained in this publication regarding device Trademarks applications and the like is provided only for your convenience The Microchip name and logo, the Microchip logo, dsPIC, and may be superseded by updates.
    [Show full text]
  • Evaluating Variability Modeling Techniques for Supporting Cyber-Physical System Product Line Engineering
    This paper will be presented at System Analysis and Modeling (SAM) Conference 2016 (http://sdl-forum.org/Events/SAM2016/index.htm) Evaluating Variability Modeling Techniques for Supporting Cyber-Physical System Product Line Engineering Safdar Aqeel Safdar 1, Tao Yue1,2, Shaukat Ali1, Hong Lu1 1Simula Research Laboratory, Oslo, Norway 2 University of Oslo, Oslo, Norway {safdar, tao, shaukat, honglu}@simula.no Abstract. Modern society is increasingly dependent on Cyber-Physical Systems (CPSs) in diverse domains such as aerospace, energy and healthcare. Employing Product Line Engineering (PLE) in CPSs is cost-effective in terms of reducing production cost, and achieving high productivity of a CPS development process as well as higher quality of produced CPSs. To apply CPS PLE in practice, one needs to first select an appropriate variability modeling technique (VMT), with which variabilities of a CPS Product Line (PL) can be specified. In this paper, we proposed a set of basic and CPS-specific variation point (VP) types and modeling requirements for proposing CPS-specific VMTs. Based on the proposed set of VP types (basic and CPS-specific) and modeling requirements, we evaluated four VMTs: Feature Modeling, Cardinality Based Feature Modeling, Common Variability Language, and SimPL (a variability modeling technique dedicated to CPS PLE), with a real-world case study. Evaluation results show that none of the selected VMTs can capture all the basic and CPS-specific VP and meet all the modeling requirements. Therefore, there is a need to extend existing techniques or propose new ones to satisfy all the requirements. Keywords: Product Line Engineering, Variability Modeling, and Cyber- Physical Systems 1 Introduction Cyber-Physical Systems (CPSs) integrate computation and physical processes and their embedded computers and networks monitor and control physical processes by often relying on closed feedback loops [1, 2].
    [Show full text]
  • UML Profile for Communicating Systems a New UML Profile for the Specification and Description of Internet Communication and Signaling Protocols
    UML Profile for Communicating Systems A New UML Profile for the Specification and Description of Internet Communication and Signaling Protocols Dissertation zur Erlangung des Doktorgrades der Mathematisch-Naturwissenschaftlichen Fakultäten der Georg-August-Universität zu Göttingen vorgelegt von Constantin Werner aus Salzgitter-Bad Göttingen 2006 D7 Referent: Prof. Dr. Dieter Hogrefe Korreferent: Prof. Dr. Jens Grabowski Tag der mündlichen Prüfung: 30.10.2006 ii Abstract This thesis presents a new Unified Modeling Language 2 (UML) profile for communicating systems. It is developed for the unambiguous, executable specification and description of communication and signaling protocols for the Internet. This profile allows to analyze, simulate and validate a communication protocol specification in the UML before its implementation. This profile is driven by the experience and intelligibility of the Specification and Description Language (SDL) for telecommunication protocol engineering. However, as shown in this thesis, SDL is not optimally suited for specifying communication protocols for the Internet due to their diverse nature. Therefore, this profile features new high-level language concepts rendering the specification and description of Internet protocols more intuitively while abstracting from concrete implementation issues. Due to its support of several concrete notations, this profile is designed to work with a number of UML compliant modeling tools. In contrast to other proposals, this profile binds the informal UML semantics with many semantic variation points by defining formal constraints for the profile definition and providing a mapping specification to SDL by the Object Constraint Language. In addition, the profile incorporates extension points to enable mappings to many formal description languages including SDL. To demonstrate the usability of the profile, a case study of a concrete Internet signaling protocol is presented.
    [Show full text]
  • Boolean Data Type & Expressions Outline Basic Data Types
    Boolean Data Type & Expressions Outline Basic Data Types 1. Boolean Data Type & Expressions Outline Numeric 2. Basic Data Types – int 3. C Boolean Data Types: char or int/ – float Boolean Declaration Non-numeric 4. Boolean or Character? – char 5. Boolean Literal Constants #include <stdio.h> 6. Boolean Expressions/ int main () Boolean Operations ¡ /* main */ 7. Example: Boolean Literal Constants & Expressions float standard_deviation, relative_humidity; int count, number_of_silly_people; 8. Example: Boolean Variables char middle_initial, hometown[30]; ¢ 9. Relational Operations /* main */ 10. Example: Relational Expressions 11. Structure of Boolean Expressions 12. Precedence Order of Boolean Operations 13. Another Boolean Precedence Example 14. Example: Boolean Precedence Order 15. Example: More Relational Expressions 16. Example: More Relational Expressions (continued) 17. Short Circuiting 18. Exercise: Writing a Program 1 2 C Boolean Data Type: char or int Boolean or Character? The C data type typically used for storing Boolean values is char, Question: How does the C compiler know that a particular char although int will also work. declaration is a Boolean rather than a character? Like numeric data types, Booleans have particular ways of being Answer: It doesn’t. stored in memory and of being operated on. % cat shortcircuit.c #include <stdio.h> Conceptually, a Boolean value represents a single bit in memory, char int int main () although the and data types aren’t implemented this ¡ /* main */ way — if for no other reason than that computers can’t address a const int maximum_short_height_in_cm = 170; single bit, since the smallest collection of bits that they can address int my_height_in_cm = 160; char I_am_Henry = 1; is a byte (or, in a few cases, a word).
    [Show full text]
  • A Decimal Floating-Point Speciftcation
    A Decimal Floating-point Specification Michael F. Cowlishaw, Eric M. Schwarz, Ronald M. Smith, Charles F. Webb IBM UK IBM Server Division P.O. Box 31, Birmingham Rd. 2455 South Rd., MS:P310 Warwick CV34 5JL. UK Poughkeepsie, NY 12601 USA [email protected] [email protected] Abstract ing is required. In the fixed point formats, rounding must be explicitly applied in software rather than be- Even though decimal arithmetic is pervasive in fi- ing provided by the hardware. To address these and nancial and commercial transactions, computers are other limitations, we propose implementing a decimal stdl implementing almost all arithmetic calculations floating-point format. But what should this format be? using binary arithmetic. As chip real estate becomes This paper discusses the issues of defining a decimal cheaper it is becoming likely that more computer man- floating-point format. ufacturers will provide processors with decimal arith- First, we consider the goals of the specification. It metic engines. Programming languages and databases must be compliant with standards already in place. are expanding the decimal data types available whale One standard we consider is the ANSI X3.274-1996 there has been little change in the base hardware. As (Programming Language REXX) [l]. This standard a result, each language and application is defining a contains a definition of an integrated floating-point and different arithmetic and few have considered the efi- integer decimal arithmetic which avoids the need for ciency of hardware implementations when setting re- two distinct data types and representations. The other quirements. relevant standard is the ANSI/IEEE 854-1987 (Radix- In this paper, we propose a decimal format which Independent Floating-point Arithmetic) [a].
    [Show full text]
  • Data Types and Variables
    Color profile: Generic CMYK printer profile Composite Default screen Complete Reference / Visual Basic 2005: The Complete Reference / Petrusha / 226033-5 / Chapter 2 2 Data Types and Variables his chapter will begin by examining the intrinsic data types supported by Visual Basic and relating them to their corresponding types available in the .NET Framework’s Common TType System. It will then examine the ways in which variables are declared in Visual Basic and discuss variable scope, visibility, and lifetime. The chapter will conclude with a discussion of boxing and unboxing (that is, of converting between value types and reference types). Visual Basic Data Types At the center of any development or runtime environment, including Visual Basic and the .NET Common Language Runtime (CLR), is a type system. An individual type consists of the following two items: • A set of values. • A set of rules to convert every value not in the type into a value in the type. (For these rules, see Appendix F.) Of course, every value of another type cannot always be converted to a value of the type; one of the more common rules in this case is to throw an InvalidCastException, indicating that conversion is not possible. Scalar or primitive types are types that contain a single value. Visual Basic 2005 supports two basic kinds of scalar or primitive data types: structured data types and reference data types. All data types are inherited from either of two basic types in the .NET Framework Class Library. Reference types are derived from System.Object. Structured data types are derived from the System.ValueType class, which in turn is derived from the System.Object class.
    [Show full text]